hecks 3.5.0 → 3.7.0

data/lib/hecks/projections/glossary/sentences.rb

@@ -1,6 +1,7 @@
 require_relative "../../naming"
 require_relative "../statements"
 require_relative "sensitivity"
+require_relative "sentences/value_objects"
 
 module Hecks
   module Projections
@@ -9,9 +10,15 @@ module Hecks
       # mechanically from one declared fact, and a fact with no plain phrasing gets none.
       # Links come only from declared structure, never from searching prose.
       module Sentences
-        TYPE_WORDS = {
-          "Integer" => "a whole number", "Float" => "a number", "String" => "text",
-          "Boolean" => "yes or no", "TrueClass" => "yes or no", "FalseClass" => "yes or no"
+        # The one sentence each kind of term other than an entity or value object carries.
+        SINGLES = {
+          command:    ->(facts, _index) { command_sentence(facts[:command]) },
+          query:      ->(facts, _index) { facts[:query].description },
+          event:      ->(facts, index) { event_sentence(facts, index) },
+          policy:     ->(facts, index) { policy_sentence(facts[:policy], index) },
+          saga:       ->(facts, index) { saga_sentence(facts[:saga], index) },
+          role:       ->(facts, index) { role_sentence(facts[:commands], index) },
+          read_model: ->(facts, _index) { facts[:read_model].description }
         }.freeze
 
         module_function
@@ -20,17 +27,16 @@ module Hecks
           facts = entry.facts
           case entry.kind
           when :entity       then holder_paragraphs(facts[:entity])
-          when :value_object then value_object_paragraphs(facts[:value_object], index, entry.within, facts.fetch(:sensitive, {}))
-          when :command      then [command_sentence(facts[:command])]
-          when :query        then [facts[:query].description]
-          when :event        then [event_sentence(facts, index)]
-          when :policy       then [policy_sentence(facts[:policy], index)]
-          when :saga         then [saga_sentence(facts[:saga], index)]
-          when :role         then [role_sentence(facts[:commands], index)]
-          when :read_model   then [facts[:read_model].description]
+          when :value_object then value_object_paragraphs(entry, index)
+          else [SINGLES.fetch(entry.kind).call(facts, index)]
           end.compact
         end
 
+        def value_object_paragraphs(entry, index)
+          facts = entry.facts
+          ValueObjects.paragraphs(facts[:value_object], index, entry.within, facts.fetch(:sensitive, {}))
+        end
+
         def holder_paragraphs(holder)
           [holder.description, holder.lifecycle && lifecycle_sentence(holder.lifecycle)].compact
         end
@@ -38,64 +44,11 @@ module Hecks
         def lifecycle_sentence(lifecycle)
           states = ([lifecycle.default] + lifecycle.transitions.map { |_name, transition| transition.target }).uniq
           "Starts out #{spoken(lifecycle.default)}. " \
-            "Can be #{Naming.to_sentence_list(states.map { |state| spoken(state) }, conj: 'or')}."
+            "Can be #{Naming.to_sentence_list(states.map { |state| spoken(state) }, conj: "or")}."
         end
 
         def spoken(state) = state.to_s.tr("_", " ")
 
-        def value_object_paragraphs(value_object, index, within, sensitive = {})
-          rules = value_object.invariants.map { |invariant| Statements.invariant_statement(invariant) }
-          [value_object_sentence(value_object, index, within, sensitive), rules_line(rules)].compact
-        end
-
-        # A one-field object whose field is just "value" reads as its type ("Text.").
-        def value_object_sentence(value_object, index, within, sensitive = {})
-          return closed_set_sentence(value_object.members) if value_object.closed_set?
-          return "A marker with no details of its own." if value_object.attributes.empty?
-
-          only = value_object.attributes.first
-          if value_object.attributes.size == 1 && only.name.to_s == "value"
-            return "#{upper_first(type_words(only, index, within))}."
-          end
-
-          fields = value_object.attributes.map { |field| field_phrase(field, index, within, sensitive[field.name.to_s]) }
-          "Made up of #{Naming.to_sentence_list(fields)}."
-        end
-
-        # "amount (a whole number)", or "medications (text, PHI)" when marked sensitive.
-        def field_phrase(field, index, within, marking = nil)
-          detail = [type_words(field, index, within), (Sensitivity.tag(marking) if marking)].compact.join(", ")
-          "#{Naming.words(field.name).downcase} (#{detail})"
-        end
-
-        def type_words(field, index, within)
-          type  = field.type.to_s
-          inner = TYPE_WORDS[type] || index.link(:value_object, type, within: within)
-          field.list? ? "a list of #{inner}" : inner
-        end
-
-        # A multi-field row leads with its first field and keeps the rest beside it,
-        # so no row loses what makes it distinct.
-        def closed_set_sentence(members)
-          if members.first && members.first.size > 1
-            rows = members.map do |row|
-              lead, *rest = row.map { |field, value| [field, value] }
-              "#{lead.last} (#{rest.map { |field, value| "#{Naming.words(field).downcase} #{value}" }.join(', ')})"
-            end
-            "One of: #{rows.join('; ')}."
-          else
-            "One of #{Naming.to_sentence_list(members.flat_map(&:values).uniq.map(&:to_s), conj: 'or')}."
-          end
-        end
-
-        # Kept apart from the definition sentence, where a reader would miss a rule.
-        def rules_line(rules)
-          return nil if rules.empty?
-
-          clauses = rules.map { |rule| lower_first(rule.sub(/\.\z/, "")) }
-          "Always true: #{clauses.join('; ')}."
-        end
-
         def command_sentence(command)
           parts = []
           parts << with_period(command.goal) if command.goal
@@ -105,7 +58,7 @@ module Hecks
 
         def event_sentence(facts, index)
           raisers = command_links(facts[:raised_by], index)
-          sentence = "Recorded after #{Naming.to_sentence_list(raisers, conj: 'or')}."
+          sentence = "Recorded after #{Naming.to_sentence_list(raisers, conj: "or")}."
           reactions = facts[:policies].map { |policy| index.link(:policy, policy.name) }
           sentence += " Prompts #{Naming.to_sentence_list(reactions)}." unless reactions.empty?
           sentence
@@ -114,14 +67,7 @@ module Hecks
         # A cross-domain trigger (`across "Compliance"`) is spoken as words with the
         # domain named, since there is nothing here to link to.
         def policy_sentence(policy, index)
-          holder, command = split_trigger(policy.trigger_command)
-          asked = if policy.target_domain
-                    "#{Naming.words(holder)} is asked to #{Naming.words(command).downcase}, " \
-                      "in #{Naming.words(policy.target_domain)}"
-                  else
-                    "#{index.link(:aggregate, holder)} is asked to #{index.link(:command, command, within: holder)}"
-                  end
-          sentence = "When #{index.link(:event, bare(policy.on_event))} happens, #{asked}"
+          sentence = "When #{index.link(:event, bare(policy.on_event))} happens, #{asked_phrase(policy, index)}"
           if policy.for_each
             query_holder, query = split_trigger(policy.for_each)
             sentence += ", once for each row of #{index.link(:query, query, within: query_holder)}"
@@ -129,11 +75,22 @@ module Hecks
           "#{sentence}."
         end
 
+        # What the policy asks of whom, linked unless the trigger crosses into another domain.
+        def asked_phrase(policy, index)
+          holder, command = split_trigger(policy.trigger_command)
+          if policy.target_domain
+            "#{Naming.words(holder)} is asked to #{Naming.words(command).downcase}, " \
+              "in #{Naming.words(policy.target_domain)}"
+          else
+            "#{index.link(:aggregate, holder)} is asked to #{index.link(:command, command, within: holder)}"
+          end
+        end
+
         def saga_sentence(shape, index)
           sentence = "Begins when #{index.link(:event, bare(shape[:starts_on]))} happens " \
                      "and ends when #{index.link(:event, bare(shape[:ends_on]))} happens."
           states = Array(shape[:states]).map { |state| spoken(state) }
-          sentence += " Along the way it can be #{Naming.to_sentence_list(states, conj: 'or')}." unless states.empty?
+          sentence += " Along the way it can be #{Naming.to_sentence_list(states, conj: "or")}." unless states.empty?
           sentence
         end
 
@@ -148,12 +105,16 @@ module Hecks
         def command_links(issues, index)
           issues = issues.uniq { |holder, command| [holder.hecks_name, command.hecks_name] }
           repeated = issues.map { |_holder, command| command.hecks_name }.tally.select { |_name, count| count > 1 }
-          issues.map do |holder, command|
-            label = if repeated.key?(command.hecks_name)
-                      "#{Naming.words(command.hecks_name)} (#{Naming.words(holder.hecks_name).downcase})"
-                    end
-            index.link(:command, command.hecks_name, within: holder.hecks_name, label: label)
-          end
+          issues.map { |holder, command| command_link(holder, command, index, repeated.key?(command.hecks_name)) }
+        end
+
+        def command_link(holder, command, index, shared)
+          label = holder_label(holder, command) if shared
+          index.link(:command, command.hecks_name, within: holder.hecks_name, label: label)
+        end
+
+        def holder_label(holder, command)
+          "#{Naming.words(command.hecks_name)} (#{Naming.words(holder.hecks_name).downcase})"
         end
 
         def split_trigger(dotted)

data/lib/hecks/projections/glossary/slugs.rb

@@ -0,0 +1,33 @@
+module Hecks
+  module Projections
+    module Glossary
+      # Reproduces GitHub's heading slugs, computed in document order, so links land the
+      # same whether GitHub renders the `.md` or `Html` renders the page.
+      module Slugs
+        module_function
+
+        def github(text) = text.to_s.downcase.gsub(/[^\p{Word}\- ]/, "").tr(" ", "-")
+
+        # Assigns every section's and entry's slug, in document order.
+        def assign!(bluebook, sections)
+          take = slug_taker
+          take.call(Markdown.title(bluebook))
+          sections.each do |section|
+            section.slug = take.call(section.title)
+            section.terms.each { |entry| entry.slug = take.call(entry.headword) }
+          end
+        end
+
+        # A lambda that answers each text's slug, numbering the repeats.
+        def slug_taker
+          seen = Hash.new(0)
+          lambda do |text|
+            base = github(text)
+            seen[base] += 1
+            seen[base] == 1 ? base : "#{base}-#{seen[base] - 1}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/glossary.rb

@@ -7,6 +7,9 @@ require_relative "glossary/sentences"
 require_relative "glossary/mermaid"
 require_relative "glossary/markdown"
 require_relative "glossary/html"
+require_relative "glossary/entries"
+require_relative "glossary/slugs"
+require_relative "glossary/index"
 
 module Hecks
   module Projections
@@ -44,7 +47,7 @@ module Hecks
       # Gathers every term, groups it into sections, assigns headings and
       # slugs, and builds the index links resolve through.
       def document(bluebook, markings = [])
-        sections = sections(bluebook, entries(bluebook, markings))
+        sections = sections(bluebook, Entries.all(bluebook, markings))
         Slugs.assign!(bluebook, sections)
         Document.new(bluebook: bluebook, sections: sections, index: Index.new(sections), markings: markings)
       end
@@ -52,28 +55,37 @@ module Hecks
       # Aggregates first, A to Z by spoken name, then the groups no aggregate homes.
       def sections(bluebook, entries)
         grouped = entries.group_by(&:section)
-        list = bluebook.aggregates.sort_by { |aggregate| Naming.words(aggregate.hecks_name).downcase }.map do |aggregate|
+        aggregate_sections(bluebook, grouped) + group_sections(grouped)
+      end
+
+      def aggregate_sections(bluebook, grouped)
+        bluebook.aggregates.sort_by { |aggregate| Naming.words(aggregate.hecks_name).downcase }.map do |aggregate|
           Section.new(name: aggregate.hecks_name, title: Naming.words(aggregate.hecks_name), aggregate: aggregate,
                       terms: with_headwords(grouped.fetch(aggregate.hecks_name, []), aggregate.hecks_name))
         end
-        [ROLES, READ_MODELS, REACTIONS].each do |name|
+      end
+
+      # The sections no aggregate homes: roles, read models and reactions, when any term belongs.
+      def group_sections(grouped)
+        [ROLES, READ_MODELS, REACTIONS].filter_map do |name|
           held = grouped[name == REACTIONS ? nil : name]
-          list << Section.new(name: name, title: name, terms: with_headwords(held, name)) if held
+          Section.new(name: name, title: name, terms: with_headwords(held, name)) if held
         end
-        list
       end
 
       # A headword is qualified only when it would repeat within its section, never numbered.
       def with_headwords(entries, section_name)
         entries.each { |entry| entry.headword = Naming.words(entry.name) }
-        entries.group_by(&:headword).each_value do |group|
-          next if group.size == 1
-
-          group.each { |entry| entry.headword = qualified(entry, group, section_name) }
-        end
+        entries.group_by(&:headword).each_value { |group| qualify_repeats(group, section_name) }
         entries.sort_by { |entry| [entry.headword.downcase, entry.kind.to_s] }
       end
 
+      def qualify_repeats(group, section_name)
+        return if group.size == 1
+
+        group.each { |entry| entry.headword = qualified(entry, group, section_name) }
+      end
+
       def qualified(entry, group, section_name)
         base = Naming.words(entry.name)
         return "#{base} (the list)" if entry.kind == :query && group.any? { |other| other.kind == :command }
@@ -81,186 +93,6 @@ module Hecks
 
         base
       end
-
-      # Entities carry their own commands and queries, so they are walked one level down.
-      def holders(bluebook)
-        bluebook.aggregates.flat_map { |aggregate| [aggregate, *aggregate.entities] }
-      end
-
-      # Maps every holder name to its owning aggregate's name.
-      def holder_aggregate(bluebook)
-        bluebook.aggregates.each_with_object({}) do |aggregate, map|
-          map[aggregate.hecks_name] = aggregate.hecks_name
-          aggregate.entities.each { |entity| map[entity.hecks_name] = aggregate.hecks_name }
-        end
-      end
-
-      # Maps each emitted event to its `[holder, command]` raisers. An event is never
-      # declared, so its home is the first raiser's aggregate.
-      def event_raisers(bluebook)
-        holders(bluebook).each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |holder, map|
-          holder.commands.each { |command| command.emits.each { |event| map[event] << [holder, command] } }
-        end
-      end
-
-      # The last segment of a dotted name.
-      def bare(qualified) = qualified.to_s.split(".").last
-
-      # Gathers every term the glossary carries, ungrouped and unordered.
-      def entries(bluebook, markings = [])
-        homes   = holder_aggregate(bluebook)
-        raisers = event_raisers(bluebook)
-        home_of = ->(event) { raisers.key?(event) ? homes[raisers[event].first.first.hecks_name] : nil }
-
-        entries = []
-        entries += entity_entries(bluebook)
-        entries += value_object_entries(bluebook, markings)
-        entries += verb_entries(bluebook, homes)
-        entries += event_entries(bluebook, raisers, home_of)
-        entries += policy_entries(bluebook, home_of)
-        entries += saga_entries(bluebook, home_of)
-        entries += role_entries(bluebook)
-        entries += read_model_entries(bluebook)
-        entries
-      end
-
-      def entity_entries(bluebook)
-        bluebook.aggregates.flat_map do |aggregate|
-          aggregate.entities.map do |entity|
-            Entry.new(name: entity.hecks_name, kind: :entity, within: aggregate.hecks_name,
-                      section: aggregate.hecks_name, facts: { entity: entity })
-          end
-        end
-      end
-
-      # Aggregates only; `Bluebook::Entity` deliberately does not answer `value_objects`.
-      def value_object_entries(bluebook, markings = [])
-        bluebook.aggregates.flat_map do |aggregate|
-          marked = Sensitivity.for_aggregate(markings, bluebook.name, aggregate)
-          aggregate.value_objects.map do |value_object|
-            sensitive = Sensitivity.for_value_object(marked, aggregate, value_object)
-            Entry.new(name: value_object.hecks_name, kind: :value_object, within: aggregate.hecks_name,
-                      section: aggregate.hecks_name,
-                      facts: { value_object: value_object, sensitive: sensitive })
-          end
-        end
-      end
-
-      def verb_entries(bluebook, homes)
-        holders(bluebook).flat_map do |holder|
-          commands = holder.commands.map do |command|
-            Entry.new(name: command.hecks_name, kind: :command, within: holder.hecks_name,
-                      section: homes[holder.hecks_name], facts: { command: command, holder: holder })
-          end
-          queries = holder.queries.map do |query|
-            Entry.new(name: query.hecks_name, kind: :query, within: holder.hecks_name,
-                      section: homes[holder.hecks_name], facts: { query: query })
-          end
-          commands + queries
-        end
-      end
-
-      def event_entries(bluebook, raisers, home_of)
-        raisers.map do |event, raised_by|
-          reactions = bluebook.policies.select { |policy| bare(policy.on_event) == event }
-          Entry.new(name: event, kind: :event, section: home_of.call(event),
-                    facts: { event: event, raised_by: raised_by, policies: reactions })
-        end
-      end
-
-      def policy_entries(bluebook, home_of)
-        bluebook.policies.map do |policy|
-          Entry.new(name: policy.name, kind: :policy, section: home_of.call(bare(policy.on_event)),
-                    facts: { policy: policy })
-        end
-      end
-
-      def saga_entries(bluebook, home_of)
-        bluebook.process_managers.map do |saga|
-          shape = saga.to_h
-          Entry.new(name: shape[:name], kind: :saga, section: home_of.call(bare(shape[:starts_on])),
-                    facts: { saga: shape })
-        end
-      end
-
-      # Roles cut across aggregates, so they get their own section.
-      def role_entries(bluebook)
-        by_role = Hash.new { |hash, key| hash[key] = [] }
-        holders(bluebook).each do |holder|
-          holder.commands.select(&:role).each { |command| by_role[command.role] << [holder, command] }
-        end
-        by_role.map do |role, issues|
-          Entry.new(name: role, kind: :role, section: ROLES, facts: { role: role, commands: issues })
-        end
-      end
-
-      # A read model joins heads from more than one aggregate, so it belongs to none.
-      def read_model_entries(bluebook)
-        bluebook.read_models.map do |read_model|
-          Entry.new(name: read_model.name, kind: :read_model, section: READ_MODELS, facts: { read_model: read_model })
-        end
-      end
-
-      # Reproduces GitHub's heading slugs, computed in document order, so links land the
-      # same whether GitHub renders the `.md` or `Html` renders the page.
-      module Slugs
-        module_function
-
-        def github(text) = text.to_s.downcase.gsub(/[^\p{Word}\- ]/, "").tr(" ", "-")
-
-        # Assigns every section's and entry's slug, in document order.
-        def assign!(bluebook, sections)
-          seen = Hash.new(0)
-          take = lambda do |text|
-            base = github(text)
-            seen[base] += 1
-            seen[base] == 1 ? base : "#{base}-#{seen[base] - 1}"
-          end
-          take.call(Markdown.title(bluebook))
-          sections.each do |section|
-            section.slug = take.call(section.title)
-            section.terms.each { |entry| entry.slug = take.call(entry.headword) }
-          end
-        end
-      end
-
-      # Resolves declared references structurally, never by searching prose. An
-      # undeclared target (a cross-domain command) answers nil and renders unlinked.
-      class Index
-        def initialize(sections)
-          @by_key = {}
-          sections.each do |section|
-            @by_key[[:aggregate, section.name]] = section if section.aggregate
-            section.terms.each { |entry| @by_key[key_of(entry)] = entry }
-          end
-        end
-
-        # Commands, queries and value objects can share a bare name across holders, so
-        # their key includes the holder.
-        def key_of(entry)
-          case entry.kind
-          when :command, :query, :value_object then [entry.kind, entry.within, entry.name]
-          else [entry.kind, entry.name]
-          end
-        end
-
-        # Looks up a term or aggregate section by kind and name.
-        #
-        # @return [Entry, Section, nil]
-        def [](kind, name, within: nil)
-          @by_key[within ? [kind, within, name] : [kind, name]]
-        end
-
-        # A Markdown link to a term's heading, or the plain words when undeclared.
-        # `label:` overrides the link text to tell two same-named terms apart.
-        def link(kind, name, within: nil, label: nil)
-          target = self[kind, name, within: within]
-          return label || Naming.words(name) unless target
-
-          text = label || (target.is_a?(Section) ? target.title : target.headword)
-          "[#{text}](##{target.slug})"
-        end
-      end
     end
   end
 end

data/lib/hecks/projections/model.rb

@@ -59,7 +59,7 @@ module Hecks
           # Generated — projected from the language's own #{name} aggregate.
           # Do not edit: the holding half is rendered, and #{host.fetch(:behaviour)}
           # is where anything hand-written belongs.
-          require_relative "behaviour/#{File.basename(host.fetch(:file), '.rb')}"
+          require_relative "behaviour/#{File.basename(host.fetch(:file), ".rb")}"
 
           module Hecks
             module Bluebook
@@ -103,13 +103,15 @@ module Hecks
       #   `Deviations` marks as parent-ref, judge-only, off-the-wire, dynamic-tail,
       #   folded, or unpacked
       def emitted_fields(bluebook, name)
-        bluebook.aggregate(name).attributes.map(&:name)
-                .reject { |f| Deviations.parent_ref?(f) } -
-          Deviations.judge_only(name) -
-          Deviations.off_the_wire(name) -
-          Deviations.dynamic_tail(name) -
-          Deviations.folded(name).values.flatten -
-          Deviations.unpacked(name).keys
+        declared = bluebook.aggregate(name).attributes.map(&:name).reject { |f| Deviations.parent_ref?(f) }
+        declared - omitted_fields(name)
+      end
+
+      # @param name [String] the construct's name
+      # @return [Array<Symbol>] the fields `Deviations` keeps out of `emits_ir`, whatever the reason
+      def omitted_fields(name)
+        Deviations.judge_only(name) + Deviations.off_the_wire(name) + Deviations.dynamic_tail(name) +
+          Deviations.folded(name).values.flatten + Deviations.unpacked(name).keys
       end
 
       # Renders the `attr_reader` line for every emitted field, plus an `attr_accessor`
@@ -118,17 +120,21 @@ module Hecks
       # @param host [Hash{Symbol => Object}] the construct's `HOST` entry
       # @return [String] the rendered reader/accessor lines, one construct's worth
       def readers(host)
-        lines = ["attr_reader #{host.fetch(:readers).map { |r| ":#{r}" }.join(', ')}"]
+        lines = ["attr_reader #{host.fetch(:readers).map { |r| ":#{r}" }.join(", ")}"]
         accessors = host.fetch(:accessors, [])
         return lines.join("\n") if accessors.empty?
 
         # The off-the-wire reason is emitted so the comment survives regeneration.
         reasons = Deviations::OFF_THE_WIRE.fetch(host.fetch(:construct, ""), {})
-        (lines + accessors.map do |a|
-          why = reasons[a]
-          (why ? "\n# #{a.to_s.capitalize}, declared and deliberately off the wire\n# #{wrap(why)}\n" : "") +
-            "attr_accessor :#{a}"
-        end).join("\n")
+        (lines + accessors.map { |a| accessor_line(a, reasons[a]) }).join("\n")
+      end
+
+      # @param accessor [Symbol] a field kept off the wire
+      # @param why [String, nil] the reason it is, when `Deviations` gives one
+      # @return [String] its `attr_accessor`, led by the reason as a comment
+      def accessor_line(accessor, why)
+        note = why ? "\n# #{accessor.to_s.capitalize}, declared and deliberately off the wire\n# #{wrap(why)}\n" : ""
+        "#{note}attr_accessor :#{accessor}"
       end
 
       # Renders the `initialize` that assigns every declared field, coerced as `HOST`

data/lib/hecks/projections/rust_vocabulary/arguments/support.rb

@@ -0,0 +1,33 @@
+module Hecks
+  module Projections
+    module RustVocabulary
+      module Arguments
+        # The free functions every `<Variant>Args::render_args` formats through, as Rust lines.
+        SUPPORT = [
+          "/// Ruby's `#inspect` of a name, as a refusal quotes it: `{:?}` on a",
+          "/// `&str`, the quoting every kernel call site used before",
+          "/// RefusalSiteArgument existed.",
+          "fn quoted(text: &str) -> String {",
+          "    format!(\"{text:?}\")",
+          "}",
+          "",
+          "/// A list argument, written the way its RefusalSiteArgument row says:",
+          "/// sorted first (before quoting), each item quoted, then joined; an",
+          "/// empty list reads `when_empty`.",
+          "fn list(items: &[&str], sorted: bool, inspect: bool, separator: &str, when_empty: &str) -> String {",
+          "    let mut items = items.to_vec();",
+          "    if sorted {",
+          "        items.sort_unstable();",
+          "    }",
+          "    if items.is_empty() {",
+          "        return when_empty.to_string();",
+          "    }",
+          "    let write = |item: &&str| if inspect { quoted(item) } else { item.to_string() };",
+          "    items.iter().map(write).collect::<Vec<_>>().join(separator)",
+          "}",
+          ""
+        ].freeze
+      end
+    end
+  end
+end