hecks 2.9.0 → 3.0.0

data/lib/hecks/hecks/deploy.behaviors

@@ -0,0 +1,74 @@
+Hecks.behaviors "Deploy" do
+  vision "A recipe, a lint, a comparison or a projection is recorded as requested before anything outside is asked."
+
+  loads "hecks.bluebook", "custodian.bluebook", "codebase.bluebook", "context_map.hecksagon", "hecks.hecksagon", "deploy.world", "environments/memory.world"
+
+  test "Project keeps a domain that has no world file as a faulted recipe" do
+    tests "Project", on: "Recipe"
+    input run: { value: "stack" }, domain: { value: "/tmp/hecks-behaviors-absent/domain" }
+    expect emits: %w[ProjectionRequested RecipeRefused RecipeFaulted]
+  end
+
+  test "Project refuses a tenant slug that is not lowercase" do
+    tests "Project", on: "Recipe"
+    input run: { value: "stack" }, domain: { value: "examples/pizzas" }, tenant: { value: "Not A Slug" }
+    expect refused: "must match"
+  end
+
+  test "Lint keeps a Makefile that is not there as a flagged lint" do
+    tests "Lint", on: "MakefileCheck"
+    input run: { value: "recipes" }, makefiles: { value: "/tmp/hecks-behaviors-absent/Makefile" }
+    expect emits: %w[LintRequested LintRefused LintFlagged]
+  end
+
+  test "Diff keeps a template that is not there as a refused comparison" do
+    tests "Diff", on: "TemplateComparison"
+    input run: { value: "stacks" }, before: { value: "/tmp/hecks-behaviors-absent/before.yaml" }, after: { value: "/tmp/hecks-behaviors-absent/after.yaml" }
+    expect emits: %w[ComparisonRequested ComparisonUnreadable ComparisonRefused]
+  end
+
+  test "Diff refuses a template with no path" do
+    tests "Diff", on: "TemplateComparison"
+    input run: { value: "stacks" }, before: { value: "" }, after: { value: "/tmp/hecks-behaviors-absent/after.yaml" }
+    expect refused: "must match"
+  end
+
+  test "ProjectOidc keeps a domain it cannot boot out of the manifests and answers" do
+    tests "ProjectOidc", on: "OidcManifest"
+    input run: { value: "manifests" }, domains: { value: "/tmp/hecks-behaviors-absent/domain" }
+    expect emits: %w[OidcProjectionRequested ManifestAnswered OidcProjected]
+  end
+
+  test "Provision refuses a slug that is not lowercase, and writes nothing" do
+    tests "Provision", on: "Tenant"
+    input directory: { value: "/tmp/hecks-behaviors-absent/domain" }, slug: { value: "Not A Slug" }, domain: { value: "Scratch" },
+          realm: { value: "Acme" }, schema: { value: "acme" }, database: { value: "hecks_tenants" }
+    expect refused: "must match"
+  end
+
+  test "Provision refuses a tenant with no realm" do
+    tests "Provision", on: "Tenant"
+    input directory: { value: "/tmp/hecks-behaviors-absent/domain" }, slug: { value: "acme" }, domain: { value: "Scratch" },
+          realm: { value: "" }, schema: { value: "acme" }, database: { value: "hecks_tenants" }
+    expect refused: "a tenant realm is named"
+  end
+
+  test "Provision on a slug that is already recorded is refused as AlreadyExists" do
+    tests "Provision", on: "Tenant"
+    setup  "Deploy::Tenant.Provision", directory: { value: "/tmp/hecks-behaviors-absent/domain" }, slug: { value: "acme" }, domain: { value: "Scratch" },
+           realm: { value: "Acme" }, schema: { value: "acme" }, database: { value: "hecks_tenants" }
+    input directory: { value: "/tmp/hecks-behaviors-absent/domain" }, slug: { value: "acme" }, domain: { value: "Scratch" },
+          realm: { value: "Acme" }, schema: { value: "acme" }, database: { value: "hecks_tenants" }
+    expect refused: "already"
+  end
+
+  # A directory that is not there is refused, so no overlay is written and the test creates
+  # nothing; the writing path runs against a real tmpdir in spec/adapters/driven/tenant_provisioner_spec.rb.
+  test "Reprovision keeps a directory that is not there as a refused provisioning" do
+    tests "Reprovision", on: "Tenant"
+    setup  "Deploy::Tenant.Provision", directory: { value: "/tmp/hecks-behaviors-absent/domain" }, slug: { value: "acme" }, domain: { value: "Scratch" },
+           realm: { value: "Acme" }, schema: { value: "acme" }, database: { value: "hecks_tenants" }
+    input  tenant: "acme", directory: { value: "/tmp/hecks-behaviors-absent/domain" }, database: { value: "hecks_tenants" }
+    expect emits: %w[TenantReprovisionRequested ProvisioningRefused ProvisioningAbandoned]
+  end
+end

data/lib/hecks/hecks/deploy.world

@@ -0,0 +1,12 @@
+# The Deploy chapter's launcher when the Hecks domain attaches it: `hecks deploy <verb>` reads the
+# world named for the chapter, as `hecks.world` does for the Hecks chapter's own verbs. Its store
+# is not set here: hecks.world's `default_adapter` fills the gap, so the memory overlay swaps it
+# with the rest.
+#
+# `run_keys` mints the `run` key of a recipe, a lint, a comparison or a manifest projection, and
+# `--wait` reports a faulted, flagged, drifted or refused run as exit 1.
+Hecks.world "Deploy" do
+  launcher "Launcher", run_keys: true,
+                       failure_states: %w[flagged failed drifted unreachable refused faulted halted stopped
+                                          abandoned red needs_fix]
+end

data/lib/hecks/hecks/environments/memory.world

@@ -0,0 +1,10 @@
+# The Memory selection for the Hecks domain: nothing is written to a database. Specs and
+# pull-request runs use it (`HECKS_ENVIRONMENT=memory`); a real run keeps the PostgresEra
+# journal named in hecks.world. The overlay's `default_adapter` wins over the base's.
+Hecks.world "Hecks" do
+  default_adapter "Memory"
+end
+
+Hecks.world "Governance" do
+  default_adapter "Memory"
+end

data/lib/hecks/hecks/governance.world

@@ -0,0 +1,7 @@
+# The Governance chapter's connection when the Hecks domain attaches it: boot reads a world
+# named for the chapter, not for the consuming domain. It is the same database hecks.world
+# names, so one journal holds both; environments/memory.world swaps it to Memory too.
+Hecks.world "Governance" do
+  default_adapter "PostgresEra"
+  default_database ENV.fetch("HECKS_DATABASE", "postgres://hecks@localhost/hecks")
+end

data/lib/hecks/hecks/hecks.behaviors

@@ -0,0 +1,62 @@
+Hecks.behaviors "Hecks" do
+  vision "A release moves tagged, published, verified; the grammar cache moves fresh, stale, fresh."
+
+  loads "hecks.bluebook", "custodian.bluebook", "codebase.bluebook", "context_map.hecksagon", "hecks.hecksagon", "environments/memory.world"
+
+  test "Tag records a version as tagged" do
+    tests "Tag", on: "Release"
+    input  version: { value: "3.0.0" }, ir_version: { value: "1.0.0" }, ships_from: { path: "/work/hecks" }
+    expect state: "tagged"
+  end
+
+  test "MarkPublished advances a tagged release" do
+    # The setup is spelled in full: the attached QualityControl chapter also has a `Tag` command.
+    tests "MarkPublished", on: "Release"
+    setup  "Hecks::Release.Tag", version: { value: "3.0.0" }, ir_version: { value: "1.0.0" }, ships_from: { path: "/work/hecks" }
+    input  version: { value: "3.0.0" }
+    expect emits: ["Published"]
+  end
+
+  test "Verify advances a published release" do
+    tests "Verify", on: "Release"
+    setup  "Hecks::Release.Tag", version: { value: "3.0.0" }, ir_version: { value: "1.0.0" }, ships_from: { path: "/work/hecks" }
+    setup  "Hecks::Release.MarkPublished", version: { value: "3.0.0" }
+    input  version: { value: "3.0.0" }
+    expect state: "verified"
+  end
+
+  test "Verify refuses a release that is only tagged" do
+    tests "Verify", on: "Release"
+    setup  "Hecks::Release.Tag", version: { value: "3.0.0" }, ir_version: { value: "1.0.0" }, ships_from: { path: "/work/hecks" }
+    input  version: { value: "3.0.0" }
+    expect refused: "state"
+  end
+
+  test "Record keeps a boot cache as fresh" do
+    tests "Record", on: "SyntaxBootCache"
+    input digest: { value: "abc123" }
+    expect state: "fresh"
+  end
+
+  test "Invalidate marks a fresh grammar cache stale" do
+    tests "Invalidate", on: "SyntaxBootCache"
+    setup  "Hecks::SyntaxBootCache.Record", digest: { value: "abc123" }
+    input  digest: { value: "abc123" }
+    expect state: "stale"
+  end
+
+  test "Rebuild makes a stale grammar cache fresh again" do
+    tests "Rebuild", on: "SyntaxBootCache"
+    setup  "Hecks::SyntaxBootCache.Record", digest: { value: "abc123" }
+    setup  "Hecks::SyntaxBootCache.Invalidate", digest: { value: "abc123" }
+    input  digest: { value: "abc123" }
+    expect state: "fresh"
+  end
+
+  test "Rebuild refuses a cache that is still fresh" do
+    tests "Rebuild", on: "SyntaxBootCache"
+    setup  "Hecks::SyntaxBootCache.Record", digest: { value: "abc123" }
+    input  digest: { value: "abc123" }
+    expect refused: "state"
+  end
+end

data/lib/hecks/hecks/hecks.bluebook

@@ -0,0 +1,124 @@
+Hecks.bluebook "Hecks" do
+  vision "What this install is, what version it runs, and whether its grammar cache can be trusted."
+  namespace "Hecks::Domain"
+
+  aggregate "Release" do
+    description "One gem version: the record of what is running and what was shipped."
+
+    attribute :version,    Version
+    attribute :ir_version, Version
+    attribute :ships_from, Checkout, optional: true
+
+    identified_by :version
+
+    value_object "Version" do
+      attribute :value, String, pattern: '^[0-9]+[.][0-9]+[.][0-9]+'
+
+      invariant("a version is present") { !value.to_s.empty? }
+    end
+
+    value_object "Checkout" do
+      attribute :path, String
+
+      invariant("a checkout is a working tree with hecks.gemspec beside lib/") { !path.to_s.empty? }
+    end
+
+    lifecycle :state, default: "tagged" do
+      transition "MarkPublished" => "published", from: "tagged"
+      transition "Verify"        => "verified",  from: %w[published verified]
+    end
+
+    command "Tag" do
+      role "Maintainer"
+      goal "Record a version as tagged, with the IR version it carries"
+
+      attribute :version,    Version
+      attribute :ir_version, Version
+      attribute :ships_from, Checkout
+
+      sets :version
+      sets :ir_version
+      sets :ships_from
+
+      emits Tagged
+    end
+
+    command "MarkPublished", from: "tagged" do
+      role "Maintainer"
+      goal "Record that a tagged version reached the gem registry"
+
+      reference_to Release
+
+      emits Published
+    end
+
+    command "Verify", from: %w[published verified] do
+      role "Maintainer"
+      goal "Record that the published version installs and boots"
+
+      reference_to Release
+
+      emits Verified
+    end
+
+    query "Shipped" do
+      description "Every version that was tagged, published and verified."
+      where(state: "verified")
+      order_by :version
+    end
+  end
+
+  aggregate "SyntaxBootCache" do
+    description "The grammar chapters' on-disk boot cache, keyed by a digest of the chapters it was built from."
+
+    attribute :digest, Digest
+
+    identified_by :digest
+
+    value_object "Digest" do
+      attribute :value, String, pattern: '[^ \t\n\r]'
+
+      invariant("a digest is present") { !value.to_s.empty? }
+    end
+
+    lifecycle :state, default: "fresh" do
+      transition "Invalidate" => "stale", from: "fresh"
+      transition "Rebuild"    => "fresh", from: "stale"
+    end
+
+    command "Record" do
+      role "Maintainer"
+      goal "Record a boot cache as built from the grammar chapters that hash to this digest"
+
+      attribute :digest, Digest
+
+      sets :digest
+
+      emits CacheRecorded
+    end
+
+    command "Invalidate", from: "fresh" do
+      role "Maintainer"
+      goal "Record that the grammar changed under the cache"
+
+      reference_to SyntaxBootCache
+
+      emits CacheInvalidated
+    end
+
+    command "Rebuild", from: "stale" do
+      role "Maintainer"
+      goal "Record that the cache was rebuilt from the current grammar"
+
+      reference_to SyntaxBootCache
+
+      emits CacheRebuilt
+    end
+
+    query "Stale" do
+      description "Every cache whose grammar changed under it and is not yet rebuilt."
+      where(state: "stale")
+      order_by :digest
+    end
+  end
+end

data/lib/hecks/hecks/hecks.hecksagon

@@ -0,0 +1,390 @@
+Hecks.hecksagon "Hecks" do
+  uses_framework "Governance"
+
+  # The chapters the gem carries: the language declared in itself (Paging comes with Bluebook),
+  # Expression, Tenancy, Deploy and QualityControl (which brings its own ports and adapters).
+  %w[Bluebook Hecksagon World Adapter Port Translation Expression Tenancy Deploy QualityControl]
+    .each { |chapter| attaches chapter }
+  # Persistence is not bound here: hecks.world's `default_adapter` binds every aggregate, so
+  # environments/memory.world can swap the whole domain without a double bind.
+
+  # The outside a journaled Custodian command reaches: each port names what its adapter does,
+  # and every ask is answered with the record's own arguments or refused with a reason.
+  Hecks::ModelCheckRun.port "DomainRuntime" do
+    asks "Check", to: ModelCheckRun do
+      attribute :run, RunKey
+      answers "ModelCheckAnswered"
+      refuses "ModelCheckRefused"
+    end
+  end
+
+  Hecks::Operation.port "DomainRuntime" do
+    asks "Execute", to: Operation do
+      attribute :run, OperationKey
+      answers "OperationAnswered"
+      refuses "OperationRefused"
+    end
+
+    asks "Refresh", to: Operation do
+      attribute :run, OperationKey
+      answers "OperationAnswered"
+      refuses "OperationRefused"
+    end
+
+    asks "Verify", to: Operation do
+      attribute :run, OperationKey
+      answers "OperationAnswered"
+      refuses "OperationRefused"
+    end
+
+    asks "Smoke", to: Operation do
+      attribute :run, OperationKey
+      answers "OperationAnswered"
+      refuses "OperationRefused"
+    end
+
+    answers_query "Follow"
+  end
+
+  Hecks::Operation.port "Terminal" do
+    asks "Open", to: Operation do
+      attribute :run, OperationKey
+      answers "OperationAnswered"
+      refuses "OperationRefused"
+    end
+  end
+
+  Hecks::Host.port "HostHttp" do
+    asks "Fetch", to: Host do
+      attribute :host, Address
+      answers "EraReported"
+      refuses "HostRefused"
+    end
+  end
+
+  Hecks::Era.port "JournalStore" do
+    asks "Examine", to: Era do
+      attribute :run, RunKey
+      answers "EraExamined"
+      refuses "EraRefused"
+    end
+
+    asks "Apply", to: Era do
+      attribute :run, RunKey
+      answers "EraChanged"
+      refuses "EraRefused"
+    end
+
+    answers_query "ScaffoldTranslation"
+    answers_query "AuditTranslation"
+    answers_query "Attestation"
+    answers_query "Compaction"
+  end
+
+  Hecks::Package.port "Git" do
+    asks "Pin", to: Package do
+      attribute :package, PackageRef
+      answers "PackagePinned"
+      refuses "PinRefused"
+    end
+  end
+
+  Hecks::Door.port "Workspace" do
+    asks "Write", to: Door do
+      attribute :run, DoorKey
+      answers "DoorAnswered"
+      refuses "DoorRefused"
+    end
+  end
+
+  Hecks::Door.port "Terminal" do
+    asks "Serve", to: Door do
+      attribute :run, DoorKey
+      answers "DoorAnswered"
+      refuses "DoorRefused"
+    end
+  end
+
+  Hecks::Build.port "RustToolchain" do
+    asks "Generate", to: Build do
+      attribute :run, BuildKey
+      answers "BuildAnswered"
+      refuses "BuildRefused"
+    end
+
+    asks "Wasm", to: Build do
+      attribute :run, BuildKey
+      answers "BuildAnswered"
+      refuses "BuildRefused"
+    end
+
+    asks "BrowserWasm", to: Build do
+      attribute :run, BuildKey
+      answers "BuildAnswered"
+      refuses "BuildRefused"
+    end
+
+    asks "Conform", to: Build do
+      attribute :run, BuildKey
+      answers "BuildAnswered"
+      refuses "BuildRefused"
+    end
+
+    asks "Replay", to: Build do
+      attribute :run, BuildKey
+      answers "BuildAnswered"
+      refuses "BuildRefused"
+    end
+
+    asks "Audit", to: Build do
+      attribute :run, BuildKey
+      answers "BuildAnswered"
+      refuses "BuildRefused"
+    end
+
+    answers_query "RustCoverage"
+  end
+
+  Hecks::FuzzRun.port "ProcessPool" do
+    asks "Sweep", to: FuzzRun do
+      attribute :run, FuzzKey
+      answers "FuzzAnswered"
+      refuses "FuzzRefused"
+    end
+  end
+
+  Hecks::FuzzRun.port "RustToolchain" do
+    asks "Measure", to: FuzzRun do
+      attribute :run, FuzzKey
+      answers "FuzzAnswered"
+      refuses "FuzzRefused"
+    end
+  end
+
+  Hecks::Operation.port "HostHttp" do
+    asks "Probe", to: Operation do
+      attribute :run, OperationKey
+      answers "OperationAnswered"
+      refuses "OperationRefused"
+    end
+  end
+
+  # Codebase: every ask goes to the SourceTree port, which examines the working tree before it
+  # carries a request out.
+  Hecks::LanguageRun.port "SourceTree" do
+    asks "Examine", to: LanguageRun do
+      attribute :run, RunKey
+      answers "LanguageExamined"
+      refuses "LanguageRefused"
+    end
+
+    asks "Perform", to: LanguageRun do
+      attribute :run, RunKey
+      answers "LanguageAnswered"
+      refuses "LanguageRefused"
+    end
+
+    answers_query "WordStatus"
+  end
+
+  Hecks::KernelRun.port "SourceTree" do
+    asks "Examine", to: KernelRun do
+      attribute :run, RunKey
+      answers "KernelExamined"
+      refuses "KernelRefused"
+    end
+
+    asks "Perform", to: KernelRun do
+      attribute :run, RunKey
+      answers "KernelAnswered"
+      refuses "KernelRefused"
+    end
+  end
+
+  Hecks::ConformanceRun.port "SourceTree" do
+    asks "Examine", to: ConformanceRun do
+      attribute :run, RunKey
+      answers "ConformanceExamined"
+      refuses "ConformanceRefused"
+    end
+
+    asks "Perform", to: ConformanceRun do
+      attribute :run, RunKey
+      answers "ConformanceAnswered"
+      refuses "ConformanceRefused"
+    end
+  end
+
+  Hecks::RegenerationRun.port "SourceTree" do
+    asks "Examine", to: RegenerationRun do
+      attribute :run, RunKey
+      answers "RegenerationExamined"
+      refuses "RegenerationRefused"
+    end
+
+    asks "Perform", to: RegenerationRun do
+      attribute :run, RunKey
+      answers "RegenerationAnswered"
+      refuses "RegenerationRefused"
+    end
+  end
+
+  Hecks::StyleRun.port "SourceTree" do
+    asks "Examine", to: StyleRun do
+      attribute :run, RunKey
+      answers "StyleExamined"
+      refuses "StyleRefused"
+    end
+
+    asks "Perform", to: StyleRun do
+      attribute :run, RunKey
+      answers "StyleAnswered"
+      refuses "StyleRefused"
+    end
+
+    answers_query "ReportComments"
+    answers_query "ReportRustComments"
+  end
+
+  Hecks::CodemodRun.port "SourceTree" do
+    asks "Examine", to: CodemodRun do
+      attribute :run, RunKey
+      answers "CodemodExamined"
+      refuses "CodemodRefused"
+    end
+
+    asks "Perform", to: CodemodRun do
+      attribute :run, RunKey
+      answers "CodemodAnswered"
+      refuses "CodemodRefused"
+    end
+  end
+
+  Hecks::TestSuiteRun.port "SourceTree" do
+    asks "Examine", to: TestSuiteRun do
+      attribute :run, RunKey
+      answers "TestSuiteExamined"
+      refuses "TestSuiteRefused"
+    end
+
+    asks "Perform", to: TestSuiteRun do
+      attribute :run, RunKey
+      answers "TestSuiteAnswered"
+      refuses "TestSuiteRefused"
+    end
+
+    answers_query "ShardSpecs"
+    answers_query "ListIoParallelSpecs"
+    answers_query "RecordPatternCases"
+  end
+
+  Hecks::CorpusRun.port "SourceTree" do
+    asks "Examine", to: CorpusRun do
+      attribute :run, RunKey
+      answers "CorpusExamined"
+      refuses "CorpusRefused"
+    end
+
+    asks "Perform", to: CorpusRun do
+      attribute :run, RunKey
+      answers "CorpusAnswered"
+      refuses "CorpusRefused"
+    end
+
+    answers_query "RustDomains"
+    answers_query "RegenOrder"
+    answers_query "CorpusRustCoverage"
+    answers_query "IrConstructs"
+    answers_query "IrDuplicates"
+    answers_query "IrImpact"
+  end
+
+  Hecks::PublishingRun.port "SourceTree" do
+    asks "Examine", to: PublishingRun do
+      attribute :run, RunKey
+      answers "PublishingExamined"
+      refuses "PublishingRefused"
+    end
+
+    asks "Perform", to: PublishingRun do
+      attribute :run, RunKey
+      answers "PublishingAnswered"
+      refuses "PublishingRefused"
+    end
+  end
+
+  # Deploy, attached above: its bluebook loads without deploy.hecksagon, so the outside its
+  # commands reach is named here as well. TenantProvisioning writes a tenant's overlay world;
+  # DeployToolchain generates and checks a recipe and projects the OIDC manifests.
+  Deploy::Tenant.port "TenantProvisioning" do
+    asks "WriteOverlay", to: Tenant do
+      attribute :database,  DatabaseName
+      attribute :adapter,   AdapterName, optional: true
+      attribute :directory, DirectoryPath
+      answers "TenantProvisioned"
+      refuses "ProvisioningRefused"
+    end
+  end
+
+  Deploy::Recipe.port "DeployToolchain" do
+    asks "Generate", to: Recipe do
+      attribute :run, RunKey
+      answers "RecipeAnswered"
+      refuses "RecipeRefused"
+    end
+  end
+
+  Deploy::MakefileCheck.port "DeployToolchain" do
+    asks "Scan", to: MakefileCheck do
+      attribute :run, RunKey
+      answers "LintAnswered"
+      refuses "LintRefused"
+    end
+  end
+
+  Deploy::TemplateComparison.port "DeployToolchain" do
+    asks "Compare", to: TemplateComparison do
+      attribute :run, RunKey
+      answers "ComparisonAnswered"
+      refuses "ComparisonUnreadable"
+    end
+  end
+
+  Deploy::OidcManifest.port "DeployToolchain" do
+    asks "Manifest", to: OidcManifest do
+      attribute :run, RunKey
+      answers "ManifestAnswered"
+      refuses "ManifestRefused"
+    end
+  end
+
+  # Queries answered from outside the domain. The bluebook declares the question and the value
+  # object its answer takes (`returns`) and never says who answers it; each `answers_query` here
+  # binds it to the port's adapter. The queries on the ports above (Follow, the Era readings,
+  # WordStatus and the rest) are bound the same way.
+  Hecks::Introspection.port "DomainRuntime" do
+    answers_query "Ir"
+    answers_query "Shape"
+    answers_query "Stores"
+    answers_query "History"
+    answers_query "Statements"
+    answers_query "Narrate"
+    answers_query "Docs"
+    answers_query "ProjectDiagrams"
+    answers_query "Glossary"
+  end
+
+  Hecks::FuzzRun.port "DomainRuntime" do
+    answers_query "GenerateSequence"
+  end
+end
+
+# The one seam where Deploy's "Tenant" (a validated request) becomes Tenancy's "Tenant" (a fact),
+# as tenancy.hecksagon declares it for the chapters booted on their own: `hecks deploy provision`
+# registers the tenant it provisioned. It sits here, after `attaches` has loaded both chapters.
+Hecks.hecksagon "Tenancy" do
+  translates "RegisterProvisionedTenant" do
+    on Tenant::TenantProvisioned
+    trigger Tenant::Register, with: { slug: :slug, domain: :domain, realm: :realm, schema: :schema }
+  end
+end