plutonium 0.67.0 → 0.68.0

data/lib/plutonium/dashboard/filter.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Dashboard
+    # A page-level control every card reads, declared with `filter`. Its value
+    # comes from the request's query string under the filter's key, and a value
+    # that is not one of the choices reads as the default, so a hand-edited URL
+    # can never reach a card block.
+    #
+    # The choices are either given (`choices:`) or are a resource's scopes
+    # (`scopes: Post`): "All" plus every scope the resource's definition
+    # declares, labelled and gated the way the index's scope pills are.
+    class Filter
+      # Keys a filter cannot take: the card route's own params and the options
+      # `url_for` reads, all of which the filter values are merged into when
+      # building each card's frame URL. A key that is a path segment of the
+      # mount (an entity scope, a `(:locale)` scope) is refused per request,
+      # since only the route knows it.
+      RESERVED_KEYS = %i[
+        card dashboard_class controller action format anchor params path_params
+        host protocol port subdomain domain tld_length user password
+        script_name original_script_name only_path trailing_slash
+        use_route _recall
+      ].freeze
+
+      # The value of a scope filter's "All" choice.
+      ALL = "all"
+
+      attr_reader :key, :resource_class
+
+      # @param choices [Hash{#to_s => String, Proc}, nil] value => label, in display order
+      # @param scopes [Class, nil] a resource whose definition's scopes are the choices
+      # @param default [#to_s, nil] one of the choices; the first (or, for
+      #   scopes, the definition's `default_scope`, else "All") when nil
+      def initialize(key, choices: nil, scopes: nil, default: nil, label: nil)
+        @key = key.to_sym
+        if RESERVED_KEYS.include?(@key)
+          raise ArgumentError, "filter #{@key.inspect}: the name is reserved by the card route, pick another"
+        end
+        unless choices.nil? ^ scopes.nil?
+          raise ArgumentError, "filter #{@key.inspect}: pass exactly one of choices: or scopes:"
+        end
+
+        @label = label
+        @default = default&.to_s
+
+        if scopes
+          raise ArgumentError, "filter #{@key.inspect}: scopes: takes a resource class, got #{scopes.inspect}" unless scopes.is_a?(Class)
+
+          @resource_class = scopes
+        else
+          @choices = choices.to_h.transform_keys(&:to_s).freeze
+          raise ArgumentError, "filter #{@key.inspect}: choices must not be empty" if @choices.empty?
+
+          @default ||= @choices.keys.first
+          validate_default!
+        end
+      end
+
+      def scopes? = !@resource_class.nil?
+
+      # The control's accessible name.
+      def label
+        Plutonium::Translation.resolve(@label) || key.to_s.humanize
+      end
+
+      # value => label for this request. Labels may be lazy `t` procs. Read it
+      # through {Base#filter_choices}, which builds it once per request.
+      def choices_for(dashboard)
+        scopes? ? scope_choices(dashboard) : @choices
+      end
+
+      # An explicit `default:` must be one of the definition's scopes. A
+      # default (explicit or the definition's `default_scope`) whose
+      # `condition:` hides it from this user reads as "All", as does a
+      # `default_scope` the definition never declares as a scope.
+      def default_for(dashboard)
+        return @default unless scopes?
+
+        if @default && !dashboard.scope_query_for(resource_class).scope_definitions.key?(@default)
+          raise ArgumentError, "filter #{key.inspect}: default #{@default.inspect} is not a scope of #{resource_class}'s definition"
+        end
+
+        default = @default || dashboard.resource_definition_for(resource_class).default_scope&.to_s
+        dashboard.filter_choices(self).key?(default) ? default : ALL
+      end
+
+      # The chosen value for this request.
+      def value_from(dashboard)
+        value = dashboard.params[key].to_s
+        dashboard.filter_choices(self).key?(value) ? value : default_for(dashboard)
+      end
+
+      private
+
+      def scope_choices(dashboard)
+        query = dashboard.scope_query_for(resource_class)
+        if query.scope_definitions.key?(ALL)
+          raise ArgumentError, "filter #{key.inspect}: #{resource_class}'s definition declares a scope named :#{ALL}, which is the filter's \"All\" choice"
+        end
+
+        visible = query.scope_definitions.keys.select { |name| query.scope_visible?(name, dashboard.view_context) }
+        {ALL => -> { Plutonium::Translation.t("plutonium.ui.table.all") }}
+          .merge(visible.to_h { |name| [name, query.scope_label(name)] })
+      end
+
+      def validate_default!
+        return if @choices.key?(@default)
+
+        raise ArgumentError, "filter #{key.inspect}: default #{@default.inspect} is not one of #{@choices.keys.inspect}"
+      end
+    end
+  end
+end

data/lib/plutonium/dashboard/link.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Dashboard
+    # A link in the dashboard's toolbar, declared with `link`: the way to a
+    # related page such as the dashboard's settings or a full report.
+    class Link
+      include Evaluation
+
+      attr_reader :key, :icon
+
+      def initialize(key, href:, label: nil, icon: nil, condition: nil)
+        @key = key.to_sym
+        @href = href
+        @label = label
+        @icon = icon
+        @condition = condition
+      end
+
+      def label
+        Plutonium::Translation.resolve(@label) || key.to_s.humanize
+      end
+
+      # Evaluated like a card's `href:`.
+      def href_for(dashboard)
+        @href.is_a?(Proc) ? evaluate_on(dashboard, @href) : @href
+      end
+
+      # Evaluated like a card's `condition:`.
+      def visible?(dashboard)
+        condition_passes?(dashboard, @condition)
+      end
+    end
+  end
+end

data/lib/plutonium/dashboard/route_resolution.rb

@@ -17,13 +17,17 @@ module Plutonium
       # @param action [String, Symbol] "show" or "card"
       # @return [Symbol, nil] the route name (e.g. :sales_dashboard_card)
       def route_name(route_set, dashboard_class, action:)
-        route = route_set.routes.find do |r|
+        route(route_set, dashboard_class, action:)&.name&.to_sym
+      end
+
+      # @return [ActionDispatch::Journey::Route, nil] the named route itself
+      def route(route_set, dashboard_class, action:)
+        route_set.routes.find do |r|
           d = r.defaults
           r.name.present? &&
             d[:action].to_s == action.to_s &&
             d[:dashboard_class].to_s == dashboard_class.name
         end
-        route&.name&.to_sym
       end
     end
   end

data/lib/plutonium/resource/query_object.rb

@@ -36,6 +36,12 @@ module Plutonium
         Plutonium::Translation.label_for(:filter, resource_class, name) || name.to_s.humanize
       end
 
+      # Display label for a scope: the plutonium.scopes.<model>.<name>
+      # convention, else the humanized name.
+      def scope_label(name)
+        Plutonium::Translation.label_for(:scope, resource_class, name) || name.to_s.humanize
+      end
+
       def initialize(resource_class, params, request_path, &)
         @resource_class = resource_class
         @params = params

data/lib/plutonium/routing/dashboard_registration.rb

@@ -114,6 +114,11 @@ module Plutonium
         # the portal's again, last, so bare helpers (`root_path` in the
         # sidebar) resolve against the engine like a source-defined controller.
         klass.include(namespace.railtie_routes_url_helpers) if namespace != Object
+        # The same anonymous `inherited` hook boots the controller before it
+        # has a name, so it never prepends the portal's views and a portal's
+        # own partials (an ejected sidebar) lose to the gem's. Boot it again
+        # now that it is named.
+        klass.boot
 
         if concern_name && (concern = concern_name.safe_constantize)
           klass.include concern

data/lib/plutonium/ui/avatar.rb

@@ -56,7 +56,7 @@ module Plutonium
           value.attached? ? value.url : nil
         elsif value.respond_to?(:url)     # bare Shrine::UploadedFile, CarrierWave, ...
           value.url
-        elsif value.is_a?(String) && value.start_with?("http", "/")
+        elsif value.is_a?(String) && value.start_with?("http", "/", "data:image/")
           value
         end
       rescue ArgumentError, URI::InvalidURIError
@@ -72,7 +72,7 @@ module Plutonium
         # A URL-shaped positional subject is really an image, not an identity:
         # route it to src so Avatar("https://…/p.png") shows the image rather
         # than hashing the URL into a seed.
-        if src.nil? && subject.is_a?(String) && subject.start_with?("http", "/")
+        if src.nil? && subject.is_a?(String) && subject.start_with?("http", "/", "data:image/")
           src = subject
           subject = nil
         end

data/lib/plutonium/ui/dashboard/board.rb

@@ -6,7 +6,9 @@ module Plutonium
       # The card grid. Every lazy card is a `<turbo-frame src loading="lazy">`
       # holding a skeleton of its own shape, so the page paints at once and
       # each card's queries run in a separate request as it scrolls into
-      # view. A card declared `lazy: false` renders inline.
+      # view. A card declared `lazy: false` renders inline. Frames carry
+      # `target="_top"` so a link inside a card navigates the page, not the
+      # card's frame.
       class Board < Plutonium::UI::Component::Base
         include Phlex::Rails::Helpers::TurboFrameTag
 
@@ -54,6 +56,7 @@ module Plutonium
               src: dashboard_card_path(card),
               loading: "lazy",
               refresh: "morph",
+              target: "_top",
               class: tokens("block", span_classes(card)),
               **refresh_attributes(card)
             ) { render Skeleton.new(card:) }

data/lib/plutonium/ui/dashboard/frame.rb

@@ -15,7 +15,7 @@ module Plutonium
         end
 
         def view_template
-          turbo_frame_tag(@card.frame_id, class: "block") do
+          turbo_frame_tag(@card.frame_id, target: "_top", class: "block") do
             render Card.for(dashboard: @dashboard, card: @card)
           end
         end

data/lib/plutonium/ui/dashboard/metric.rb

@@ -9,7 +9,7 @@ module Plutonium
       #
       #   {value: 1_240}                                   # just the number
       #   {value: 1_240, previous: 1_100}                  # change computed: +12.7%
-      #   {value: 1_240, change: 12.7}                     # change in percentage points
+      #   {value: 1_240, change: 12.7}                     # +12.7% (+12.7 pts with change_unit: :points)
       #   {value: 1_240, change: "+140", trend: :up}       # change shown verbatim
       #   {value: 98.2, change_label: "vs. last week"}     # caption after the change
       #
@@ -36,13 +36,22 @@ module Plutonium
           data[:change_label] ||= card.options[:change_label]
 
           if !data.key?(:change) && data[:previous].is_a?(Numeric) && data[:value].is_a?(Numeric)
-            data[:change] = percent_change(data[:value], data[:previous])
+            data[:change] = points? ? data[:value] - data[:previous] : percent_change(data[:value], data[:previous])
           end
 
+          # Round to the precision the change is shown at, so float noise
+          # (0.3 against 0.1 + 0.2) reads as no change rather than "-0" heading
+          # down. `+ 0.0` turns a rounded -0.0 into 0.0.
+          data[:change] = data[:change].round(1) + 0.0 if data[:change].is_a?(Numeric)
+
+          # A `previous` of zero leaves a percent `change` nil but still sets
+          # the trend key, so a captioned row shows a neutral dash.
           data[:trend] ||= infer_trend(data[:change]) if data.key?(:change)
           data
         end
 
+        def points? = card.options[:change_unit] == :points
+
         def percent_change(value, previous)
           return nil if previous.zero?
 
@@ -65,9 +74,12 @@ module Plutonium
         end
 
         def render_change(data)
+          # A caption with no change or trend (a count of ratings, say) is
+          # not a trend: no icon, neutral tone.
+          trending = data.key?(:trend)
           trend = data[:trend] || :flat
-          div(class: tokens("pu-metric-change", change_tone_class(trend))) do
-            render_trend_icon(trend)
+          div(class: tokens("pu-metric-change", change_tone_class(trending ? trend : :flat))) do
+            render_trend_icon(trend) if trending
             span(class: "font-medium") { format_change(data[:change]) } if data[:change]
             span(class: "pu-metric-change-label") { data[:change_label] } if data[:change_label].present?
           end
@@ -93,7 +105,8 @@ module Plutonium
           case change
           when Numeric
             sign = change.positive? ? "+" : ""
-            "#{sign}#{number_to_rounded(change, precision: 1, strip_insignificant_zeros: true)}%"
+            rounded = number_to_rounded(change, precision: 1, strip_insignificant_zeros: true)
+            points? ? t("plutonium.dashboard.metric.points", change: "#{sign}#{rounded}") : "#{sign}#{rounded}%"
           else change.to_s
           end
         end

data/lib/plutonium/ui/dashboard/toolbar.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Dashboard
+      # The row above the card grid: each filter as a segmented control of
+      # links, so the choice is a plain URL that survives a reload and can be
+      # shared, and the dashboard's links on the right.
+      class Toolbar < Plutonium::UI::Component::Base
+        def initialize(dashboard:)
+          @dashboard = dashboard
+        end
+
+        def render?
+          dashboard.class.filters.any? || links.any?
+        end
+
+        def view_template
+          div(class: "pu-dashboard-toolbar mb-4 flex flex-wrap items-center justify-between gap-3") do
+            div(class: "flex flex-wrap items-center gap-3") do
+              dashboard.class.filters.each { |filter| render_filter(filter) }
+            end
+            div(class: "flex flex-wrap items-center gap-2") do
+              links.each { |link, href| render_link(link, href) }
+            end
+          end
+        end
+
+        private
+
+        attr_reader :dashboard
+
+        # Visible links paired with their href. A link whose `href:` resolves
+        # to nil (a proc that returns nothing for this user) is left out
+        # rather than rendered as a dead button.
+        def links
+          @links ||= dashboard.visible_links.filter_map do |link|
+            href = link.href_for(dashboard)
+            [link, href] if href.present?
+          end
+        end
+
+        def render_filter(filter)
+          current = dashboard.filter_value(filter.key)
+          nav(class: "pu-dashboard-filter inline-flex rounded-[var(--pu-radius-md)] border border-[var(--pu-border)] p-0.5",
+            aria: {label: filter.label}, data: {dashboard_filter: filter.key}) do
+            dashboard.filter_choices(filter).each do |value, label|
+              selected = value == current
+              a(
+                href: filter_url(filter, value),
+                class: tokens(
+                  "rounded-[var(--pu-radius-sm)] px-3 py-1 text-sm transition-colors",
+                  selected ? "bg-[var(--pu-surface-alt)] font-medium text-[var(--pu-text)]" : "text-[var(--pu-text-muted)] hover:text-[var(--pu-text)]"
+                ),
+                aria: {current: selected ? "true" : nil}
+              ) { Plutonium::Translation.resolve(label) }
+            end
+          end
+        end
+
+        def render_link(link, href)
+          a(href:, class: "pu-btn pu-btn-sm pu-btn-outline", data: {dashboard_link: link.key}) do
+            render link.icon.new(class: "size-4") if link.icon
+            span { link.label }
+          end
+        end
+
+        # The page with this filter set and the rest of the query string kept.
+        def filter_url(filter, value)
+          query = dashboard.request.query_parameters.merge(filter.key.to_s => value)
+          "#{dashboard.request.path}?#{query.to_query}"
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/base.rb

@@ -147,6 +147,26 @@ module Plutonium
           # has to be re-pointed explicitly or habtm skips the policy scope.
           alias_method :has_and_belongs_to_many_tag, :secure_association_tag
 
+          # List-style variants of the association input: one control per
+          # authorized record instead of a slim-select. Same policy scoping,
+          # SGID validation and inline "+" add button.
+          def secure_association_checkboxes_tag(**, &)
+            create_component(Components::SecureAssociationCheckboxes, :association_checkboxes, **, &)
+          end
+          alias_method :association_checkboxes_tag, :secure_association_checkboxes_tag
+
+          def secure_association_toggles_tag(**, &)
+            create_component(Components::SecureAssociationToggles, :association_toggles, **, &)
+          end
+          alias_method :association_toggles_tag, :secure_association_toggles_tag
+          alias_method :association_switches_tag, :secure_association_toggles_tag
+
+          def secure_association_radio_buttons_tag(**, &)
+            create_component(Components::SecureAssociationRadioButtons, :association_radio_buttons, **, &)
+          end
+          alias_method :association_radio_buttons_tag, :secure_association_radio_buttons_tag
+          alias_method :association_radios_tag, :secure_association_radio_buttons_tag
+
           def secure_polymorphic_association_tag(**attributes, &)
             attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
             create_component(Components::SecurePolymorphicAssociation, :polymorphic_association, **attributes, &)

data/lib/plutonium/ui/form/components/secure_association.rb

@@ -87,14 +87,25 @@ module Plutonium
             uri.to_s
           end
 
+          # Capped at `choice_limit`, plus the records the field holds now:
+          # one past the cap or outside the viewer's scope would otherwise not
+          # render, and saving the form would drop it (a select falls back to
+          # its blank option, an unrendered checkbox is not submitted).
           def choices
             @choices ||= begin
               collection = @raw_choices || authorized_relation
-              collection = collection.limit(@choice_limit) if @choice_limit && collection.respond_to?(:limit)
+              if collection.is_a?(ActiveRecord::Relation)
+                collection = collection.limit(@choice_limit) if @choice_limit
+                collection = (collection.to_a + selected_records).uniq
+              end
               build_choice_mapper(collection)
             end
           end
 
+          def selected_records
+            @selected_records ||= Array(field.object.public_send(association_reflection.name))
+          end
+
           # Builds the authorized association relation. Shared by `choices`
           # (which then applies `choice_limit`) and `normalize_simple_input`
           # (which validates against the full set so typeahead picks beyond
@@ -106,8 +117,11 @@ module Plutonium
             authorized_resource_scope(klass, relation: relation)
           end
 
+          # AssociationBase#build_attributes already calls
+          # build_association_attributes. Calling it here too ran it twice, and
+          # the second pass re-read the keys the first had deleted, silently
+          # dropping `skip_authorization:` and `add_action:`.
           def build_attributes
-            build_association_attributes
             super
             # Stash; the URL helper needs view_context which only exists
             # once we're rendering.
@@ -163,8 +177,16 @@ module Plutonium
           # not include records reachable via typeahead). For explicit
           # `@raw_choices`, fall back to membership in the rendered list.
           def normalize_simple_input(input_value)
+            # An explicit blank (the select's blank option, a "None" radio)
+            # clears a singular association: "" survives resource_params'
+            # `compact` and `<name>_sgid = ""` locates nil. A field that was not
+            # submitted arrives as nil and is left alone.
+            return "" if input_value == "" && !attributes[:multiple]
+
             sgid = SignedGlobalID.parse(input_value.presence)
             return nil unless sgid
+            # Keeping what the field already holds is not a new grant.
+            return sgid if selected_records.map(&:to_global_id).include?(sgid)
 
             if @raw_choices
               @signed_global_ids ||= choices.values.map { |choice| SignedGlobalID.parse(choice) }
@@ -177,13 +199,14 @@ module Plutonium
             nil
           end
 
+          # Compared as URI strings: URI objects don't match by value in a Set.
           def selected?(option)
-            case association_reflection.macro
-            when :belongs_to, :has_one
-              singular_field_value == SignedGlobalID.parse(option)
-            when :has_many, :has_and_belongs_to_many
-              collection_field_value.any? { |item| item == SignedGlobalID.parse(option) }
-            end
+            selected_gids.include?(SignedGlobalID.parse(option)&.uri&.to_s)
+          end
+
+          def selected_gids
+            @selected_gids ||= Array(attributes[:multiple] ? collection_field_value : singular_field_value)
+              .compact.to_set { |sgid| sgid.uri.to_s }
           end
 
           def singular_field_value

data/lib/plutonium/ui/form/components/secure_association_checkboxes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # A has_many / habtm association rendered as one checkbox per authorized
+        # record (`input :tags, as: :association_checkboxes`).
+        class SecureAssociationCheckboxes < SecureAssociationChoices
+          protected
+
+          def control_type = :checkbox
+
+          def control_theme = :association_checkbox
+
+          def supported_macros = %i[has_many has_and_belongs_to_many]
+
+          # Unchecked boxes are not submitted, so without this blank value
+          # clearing every box would leave the param out entirely and keep the
+          # existing records. The blank is dropped by normalize_array_input.
+          # Disabled with the list: a disabled list submits no boxes, so a live
+          # blank would save as "no records" and wipe the association.
+          def render_hidden_input
+            input(type: :hidden, name: attributes[:name], value: "", autocomplete: "off", hidden: true, disabled: attributes[:disabled])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/secure_association_choices.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Abstract base for the list-style association inputs: every choice is
+        # rendered as its own control (checkbox, toggle or radio button) instead
+        # of an option inside a slim-select.
+        #
+        # Everything that makes the association input "secure" is inherited from
+        # {SecureAssociation} unchanged: the choices come from the policy-scoped
+        # relation (or `choices:`), each value is a signed global id, submitted
+        # ids are validated against the authorized relation, and the inline "+"
+        # add button still renders. Only the markup differs.
+        #
+        # Subclasses declare the control's input type, the macros they accept and
+        # the theme key their controls style off.
+        class SecureAssociationChoices < SecureAssociation
+          def view_template
+            div(class: "flex items-start space-x-1") do
+              # The wrapper's <label for=> points at this id, but a label can't
+              # name a div, so the group carries the field label itself.
+              div(**group_attributes) do
+                render_hidden_input
+                render_blank_choice if include_blank?
+                render_choices
+              end
+              render_add_button
+            end
+          end
+
+          protected
+
+          # The type attribute of each control: "checkbox" or "radio".
+          def control_type = raise(NotImplementedError, "#{self.class}#control_type")
+
+          # Theme key the individual controls style off.
+          def control_theme = raise(NotImplementedError, "#{self.class}#control_theme")
+
+          # Association macros this variant can represent.
+          def supported_macros = raise(NotImplementedError, "#{self.class}#supported_macros")
+
+          def group_role = "group"
+
+          # Everything the caller passed (data-*, aria-*, ...) lands on the
+          # group; what belongs to a form control goes on each choice instead.
+          CONTROL_ATTRIBUTES = %i[name required disabled multiple size autofocus form value].freeze
+
+          def group_attributes
+            mix(attributes.except(*CONTROL_ATTRIBUTES), {role: group_role, aria: {label: field.label}})
+          end
+
+          def build_association_attributes
+            super
+
+            unless supported_macros.include?(association_reflection.macro)
+              raise ArgumentError,
+                "#{self.class.name.demodulize} does not support #{association_reflection.macro} " \
+                "associations (#{association_name}). Supported: #{supported_macros.join(", ")}."
+            end
+
+            if association_reflection.polymorphic?
+              raise ArgumentError, "#{self.class.name.demodulize} does not support polymorphic associations (#{association_name})."
+            end
+          end
+
+          def association_name = "#{field.object.class.name}##{association_reflection.name}"
+
+          def build_attributes
+            super
+            if @group_method
+              raise ArgumentError, "#{self.class.name.demodulize} does not support group_method: (#{association_name})."
+            end
+
+            # Typeahead drives a slim-select dropdown; a rendered list has no
+            # search box to wire it to.
+            @typeahead_option = false
+          end
+
+          def render_choices
+            if choices.values.empty?
+              p(class: "pu-hint") { Plutonium::Translation.t("plutonium.ui.form.association_choices.empty") }
+              return
+            end
+
+            choices.each.with_index do |(value, text), index|
+              render_choice(value:, text:, id: "#{attributes[:id]}_#{index}", checked: selected?(value), autofocus: index.zero? && attributes[:autofocus])
+            end
+          end
+
+          def render_choice(value:, text:, id:, checked:, autofocus: false)
+            label(for: id, class: themed(:association_choice_label, field)) do
+              input(
+                type: control_type,
+                id:,
+                name: attributes[:name],
+                value:,
+                checked:,
+                required: control_required?,
+                disabled: attributes[:disabled],
+                form: attributes[:form],
+                autofocus:,
+                class: themed(control_theme, field)
+              )
+              span { text }
+            end
+          end
+
+          def render_hidden_input
+          end
+
+          def render_blank_choice
+          end
+
+          def include_blank? = false
+
+          def control_required? = false
+        end
+      end
+    end
+  end
+end