rivet_cms 0.1.2.pre → 0.3.0

data/app/controllers/rivet_cms/application_controller.rb

@@ -1,5 +1,223 @@
 module RivetCms
-  class ApplicationController < ActionController::Base
-    #include RivetCmsAuth::Authentication
+  # Inherits from the host-configured parent controller so host auth filters and
+  # helpers are available. Do not reference this class from initializers — the
+  # parent is resolved when Zeitwerk first loads it.
+  class ApplicationController < RivetCms.parent_controller.constantize
+    layout "rivet_cms/application"
+
+    # Organization first: built-in authentication scopes its user lookup to it
+    before_action :set_current_organization
+    before_action :authenticate_rivet_user
+    before_action :set_rivet_current_user
+    after_action :set_csrf_cookie
+
+    inertia_config version: -> { RivetCms.asset_version }
+
+    inertia_share app_version: RivetCms::VERSION,
+                  nav: -> { navigation_props },
+                  media_accept: -> { RivetCms.allowed_media_types&.join(",") },
+                  flash: -> { { notice: flash.notice, alert: flash.alert } },
+                  auth: -> {
+                    user = Current.user
+                    { name: RivetCms.user_name.call(user), email: RivetCms.user_email.call(user) } if user
+                  },
+                  paths: -> {
+                    {
+                      root: root_path,
+                      content: content_path,
+                      media: media_assets_path,
+                      content_types: content_types_path,
+                      new_content_type: new_content_type_path,
+                      content_types_trash: trash_content_types_path,
+                      components: components_path,
+                      new_component: new_component_path,
+                      api_tokens: api_tokens_path,
+                      api_docs: api_docs_path,
+                      login: effective_login_path,
+                      logout: effective_logout_path,
+                      logout_method: RivetCms.builtin_auth? ? "delete" : RivetCms.logout_method
+                    }
+                  }
+
+    rescue_from RivetCms::AccessDenied, with: :deny_authorization
+
+    private
+
+    # Sidebar from the Navigation registry: items a user cannot reach are
+    # dropped here, so hiding and denying share one source of truth. Sections
+    # appear where their lowest-position item falls.
+    def navigation_props
+      sections = []
+      RivetCms::Navigation.items.each do |item|
+        next if item.visible && instance_exec(&item.visible) != true
+        next if item.requires && !can?(*item.requires)
+
+        path = item.path.respond_to?(:call) ? instance_exec(&item.path) : item.path
+        section = sections.find { |s| s[:section] == item.section } ||
+                  (sections << { section: item.section, items: [] }).last
+        entry = { key: item.key, label: item.label, icon: item.icon, path: path, exact: item.exact }
+        badge = nav_badge(item)
+        entry[:badge] = badge if badge&.positive?
+        section[:items] << entry
+      end
+      sections
+    end
+
+    # A raising badge lambda loses its badge, not the sidebar
+    def nav_badge(item)
+      return nil unless item.badge
+
+      Integer(instance_exec(&item.badge))
+    rescue StandardError => error
+      Rails.logger&.error("[RivetCms] nav badge for #{item.key} raised (skipping): #{error.class}: #{error.message}")
+      nil
+    end
+
+    # Fails closed: a raising policy denies and logs rather than 500ing the admin
+    def can?(action, resource, record: nil)
+      check = RivetCms::AccessCheck.new(
+        user: Current.user, action: action, resource: resource,
+        organization: Current.organization, record: record
+      )
+      RivetCms.can.call(check) == true
+    rescue Exception => error
+      Rails.logger&.error("[RivetCms] can policy raised (denying): #{error.class}: #{error.message}")
+      false
+    end
+
+    def authorize!(action, resource, record: nil)
+      raise RivetCms::AccessDenied, "#{action} #{resource}" unless can?(action, resource, record: record)
+    end
+
+    # List surfaces must not show what a record's own page would refuse, so
+    # every list filters through the record phase. Filtering happens after
+    # pagination, so a page can come up short; stat counts stay aggregates.
+    def permitted(records, action, resource)
+      records.select { |record| can?(action, resource, record: record) }
+    end
+
+    # Cross-type entry lists check the entry and its type, so denying a type
+    # hides its entries everywhere the type itself is hidden
+    def permitted_documents(documents)
+      permitted(documents, :read, :content)
+        .select { |document| can?(:read, :content, record: document.content_type) }
+    end
+
+    # Trashing something should land back where the delete came from, except
+    # when the referer is a page that just died with the trashed record.
+    def redirect_after_trash(dead_path, fallback, **flash)
+      referer_path = begin
+        URI.parse(request.referer.to_s).path
+      rescue URI::Error
+        nil
+      end
+      if referer_path == dead_path
+        redirect_to fallback, status: :see_other, **flash
+      else
+        redirect_back fallback_location: fallback, allow_other_host: false, status: :see_other, **flash
+      end
+    end
+
+    # Emits onto the :audit stream; call after a mutation succeeded
+    def audit(action, subject, **metadata)
+      RivetCms::Audit.record(action, subject: subject, actor: Current.user,
+                             organization: Current.organization, metadata: metadata)
+    end
+
+    def deny_authorization
+      message = "You do not have permission to do that"
+      # Inertia visits redirect (the client follows and shows the flash).
+      # Everything else that is not a plain browser page load — API clients,
+      # axios calls whose Accept header Rails reads as browser-like, any
+      # non-GET — must get a real 403 so failures surface as failures.
+      if !request.inertia? && (request.format.json? || request.xhr? || !request.get?)
+        render json: { errors: [ message ] }, status: :forbidden
+      else
+        # Redirecting to the page we just denied would loop, so only trust a
+        # referer that points somewhere else; the dashboard is always reachable.
+        referer_path = URI.parse(request.referer.to_s).path rescue nil
+        if referer_path.present? && referer_path != request.path
+          redirect_back fallback_location: root_path, allow_other_host: false,
+                        status: (request.get? ? :found : :see_other), alert: message
+        else
+          redirect_to root_path, status: (request.get? ? :found : :see_other), alert: message
+        end
+      end
+    end
+
+    # Inertia (axios) reads the XSRF-TOKEN cookie and sends it back as a header.
+    def set_csrf_cookie
+      cookies["XSRF-TOKEN"] = form_authenticity_token
+    end
+
+    def authenticate_rivet_user
+      return builtin_authenticate if RivetCms.builtin_auth?
+
+      result = RivetCms.authenticate.call(self)
+      return if performed? # the lambda rendered/redirected on its own
+      return if result     # truthy => allowed
+
+      deny_rivet_access    # falsy and unhandled => fail closed
+    end
+
+    def builtin_authenticate
+      return if builtin_session_user
+
+      if request.inertia?
+        head :unauthorized
+      elsif RivetCms::User.where(organization: Current.organization).none?
+        redirect_to setup_path # first run: create the owner account
+      else
+        redirect_to login_path
+      end
+    end
+
+    def builtin_session_user
+      return @builtin_session_user if defined?(@builtin_session_user)
+
+      user = RivetCms::User.where(organization: Current.organization)
+                           .find_by(id: session[:rivet_cms_user_id])
+      # can_sign_in?: deactivation and a wiped password both end the session.
+      # The salt comparison ends every session issued before a password change.
+      valid = user&.can_sign_in? &&
+              ActiveSupport::SecurityUtils.secure_compare(user.password_salt.to_s, session[:rivet_cms_password_salt].to_s)
+      @builtin_session_user = valid ? user : nil
+    end
+
+    def deny_rivet_access
+      if request.inertia?
+        head :unauthorized
+      elsif RivetCms.login_path.present?
+        redirect_to RivetCms.login_path
+      else
+        render plain: "RivetCms: authentication required.", status: :forbidden
+      end
+    end
+
+    def set_rivet_current_user
+      Current.user = RivetCms.builtin_auth? ? builtin_session_user : RivetCms.current_user.call(self)
+    end
+
+    def effective_login_path
+      RivetCms.builtin_auth? ? login_path : RivetCms.login_path
+    end
+
+    def effective_logout_path
+      RivetCms.builtin_auth? ? logout_path : RivetCms.logout_path
+    end
+
+    def set_current_organization
+      RivetCms::Current.organization =
+        Organization.find_by(domain: request.host) ||
+        Organization.find_by(domain: "localhost") ||
+        Organization.first ||
+        default_organization
+    end
+
+    def default_organization
+      return unless Rails.env.development? || Rails.env.test?
+
+      Organization.create!(name: "Development Org", domain: "localhost", subdomain: "dev")
+    end
   end
 end

data/app/controllers/rivet_cms/auth_controller.rb

@@ -0,0 +1,28 @@
+module RivetCms
+  # Base for the built-in auth surfaces (login, first-run setup, invitation
+  # links). Reachable without a session by definition; hard 404 when the host
+  # brought its own authentication so they add no surface area in that mode.
+  class AuthController < ApplicationController
+    skip_before_action :authenticate_rivet_user
+    skip_before_action :set_rivet_current_user
+    before_action :ensure_builtin_mode
+
+    private
+
+    def ensure_builtin_mode
+      head :not_found unless RivetCms.builtin_auth?
+    end
+
+    def sign_in(user)
+      reset_session # session fixation
+      session[:rivet_cms_user_id] = user.id
+      # Binding the session to the password salt revokes every session the
+      # moment the password changes
+      session[:rivet_cms_password_salt] = user.password_salt
+    end
+
+    def users
+      User.where(organization: Current.organization)
+    end
+  end
+end

data/app/controllers/rivet_cms/components_controller.rb

@@ -1,7 +1,98 @@
 module RivetCms
   class ComponentsController < ApplicationController
+    include InertiaProps
+
+    before_action -> { authorize! :read, :schema }, only: [ :index, :show ]
+    before_action -> { authorize! :delete, :schema }, only: [ :destroy ]
+    before_action -> { authorize! :write, :schema }, except: [ :index, :show, :destroy ]
+    before_action :set_component, only: [ :show, :update, :destroy ]
+    # Record layer: same gates, about this specific component
+    before_action -> { authorize! :read, :schema, record: @component }, only: [ :show ]
+    before_action -> { authorize! :write, :schema, record: @component }, only: [ :update ]
+    before_action -> { authorize! :delete, :schema, record: @component }, only: [ :destroy ]
+
     def index
-      @components = RivetCms::Component.all
+      field_counts = Field.where(component_id: Current.organization.components.select(:id)).group(:component_id).count
+
+      render inertia: "Components/Index", props: {
+        components: permitted(Current.organization.components.includes(:category), :read, :schema).map { |c|
+          component_props(c).merge(fields_count: field_counts.fetch(c.id, 0))
+        }
+      }
+    end
+
+    def new
+      render inertia: "Components/New", props: {
+        categories: Current.organization.categories.order(:name).map { |c| category_props(c) },
+        create_category_path: create_category_components_path
+      }
+    end
+
+    def create
+      component = Component.new(component_params)
+
+      if component.save
+        audit "component.created", component
+        redirect_to component_path(component), notice: "Component created successfully"
+      else
+        redirect_to new_component_path, inertia: { errors: component.errors }
+      end
+    end
+
+    def show
+      render inertia: "Components/Show", props: {
+        component: component_props(@component),
+        categories: Current.organization.categories.order(:name).map { |c| category_props(c) },
+        create_category_path: create_category_components_path,
+        fields: @component.fields.kept.ordered.map { |f| field_props(f) },
+        field_types: Field::FIELD_TYPE_LABELS.except("component"),
+        reference_targets: permitted(Current.organization.content_types.order(:name), :read, :schema).map { |ct| { id: ct.id, name: ct.name } },
+        embeddable_components: []
+      }
+    end
+
+    def update
+      if @component.update(component_params)
+        audit "component.updated", @component
+        redirect_to component_path(@component), notice: "Component updated successfully"
+      else
+        redirect_to component_path(@component), inertia: { errors: @component.errors }
+      end
+    end
+
+    def destroy
+      @component.destroy
+      audit "component.deleted", @component
+      redirect_to components_path, notice: "Component deleted"
+    rescue ActiveRecord::InvalidForeignKey
+      redirect_to components_path, alert: "Component is in use and cannot be deleted"
+    end
+
+    def create_category
+      category = Category.new(category_params)
+      category.slug = category.name.to_s.parameterize if category.slug.blank?
+      category.system = false if category.system.nil?
+
+      if category.save
+        audit "category.created", category
+        render json: { id: category.id, name: category.name }
+      else
+        render json: { errors: category.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def set_component
+      @component = Current.organization.components.find(params[:id])
+    end
+
+    def component_params
+      params.require(:component).permit(:name, :slug, :description, :category_id)
+    end
+
+    def category_params
+      params.require(:category).permit(:name)
     end
   end
-end
+end

data/app/controllers/rivet_cms/content_controller.rb

@@ -0,0 +1,105 @@
+module RivetCms
+  class ContentController < ApplicationController
+    # The read API is token-gated (or public when RivetCms.public_api), so host
+    # admin auth/CSRF must not run, and the org comes from the token, not the host.
+    skip_before_action :authenticate_rivet_user
+    skip_before_action :set_rivet_current_user
+    skip_before_action :set_current_organization
+    skip_after_action :set_csrf_cookie
+
+    before_action :resolve_api_access
+
+    def index
+      populate = query.populate_fields
+
+      page = query.documents
+      revisions = page.map(&:published_revision)
+      preload = RevisionPreloader.new(revisions, populate_fields: populate)
+
+      render json: {
+        data: revisions.map { |revision|
+          RevisionSerializer.new(revision, fields: query.field_keys, populate: populate, preload: preload).as_json
+        },
+        meta: { page: page.current_page, per_page: page.limit_value, total: page.total_count, total_pages: page.total_pages }
+      }
+    end
+
+    def show
+      return head :forbidden if preview_requested? && !preview_scope?
+
+      populate = query.populate_fields
+
+      document = content_type.documents.find_by!(slug: params[:slug])
+      preview = preview_requested?
+      revision = preview ? (document.draft_revision || document.published_revision) : document.published_revision
+      return head :not_found if revision.nil?
+
+      preload = RevisionPreloader.new([ revision ], populate_fields: populate, preview: preview)
+      render json: RevisionSerializer.new(revision, fields: query.field_keys, populate: populate, preview: preview, preload: preload).as_json
+    end
+
+    private
+
+    def resolve_api_access
+      raw = bearer_token
+      if raw.present?
+        token = ApiToken.authenticate(raw)
+        return render_unauthorized if token.nil?
+
+        RivetCms::Current.organization = token.organization
+        @api_scope = token.scope.to_sym
+        token.touch_used!
+      elsif RivetCms.public_api
+        set_current_organization
+        @api_scope = :published
+      else
+        render_unauthorized
+      end
+    end
+
+    def bearer_token
+      request.authorization.to_s[/\ABearer (.+)\z/i, 1]
+    end
+
+    def render_unauthorized
+      response.set_header("WWW-Authenticate", 'Bearer realm="RivetCms delivery API"')
+      render json: { error: "Invalid or missing API token" }, status: :unauthorized
+    end
+
+    def preview_requested?
+      ActiveModel::Type::Boolean.new.cast(params[:preview])
+    end
+
+    def preview_scope?
+      @api_scope == :preview
+    end
+
+    def content_type
+      @content_type ||= Current.organization.content_types.find_by!(slug: params[:content_type_slug])
+    end
+
+    def query
+      @query ||= ContentQuery.new(
+        content_type,
+        sort: params[:sort],
+        filters: date_range_params,
+        page: params[:page],
+        per_page: params[:per_page],
+        populate: params[:populate].to_s,
+        fields: params[:fields].to_s
+      )
+    end
+
+    def date_range_params
+      params.to_unsafe_h.select { |_key, value| value.is_a?(Hash) && (value.key?("gte") || value.key?("lte")) }
+    end
+
+    rescue_from ContentQuery::Error do |error|
+      render json: { error: error.message }, status: :bad_request
+    end
+
+    rescue_from ActiveRecord::RecordNotFound do
+      render json: { error: "Not found" }, status: :not_found
+    end
+  end
+end

data/app/controllers/rivet_cms/content_manager_controller.rb

@@ -0,0 +1,32 @@
+module RivetCms
+  class ContentManagerController < ApplicationController
+    include InertiaProps
+
+    before_action -> { authorize! :read, :content }
+
+    def index
+      content_types = Current.organization.content_types.order(:name)
+      documents = Document.where(organization: Current.organization).in_visible_types.order(updated_at: :desc)
+      if params[:type].present?
+        documents = documents.joins(:content_type).where(rivet_cms_content_types: { slug: params[:type] })
+      end
+      documents = documents.search(params[:q]) if params[:q].present?
+      page = documents.includes(:draft_revision, :content_type).page(params[:page]).per(25)
+      visible = permitted_documents(page)
+      titles = document_titles(visible)
+
+      render inertia: "ContentManager/Index", props: {
+        content_types: permitted(content_types, :read, :content).map { |content_type| content_type_ref_props(content_type) },
+        documents: visible.map { |document|
+          document_list_props(document, titles).merge(
+            content_type_name: document.content_type.name,
+            content_type_slug: document.content_type.slug
+          )
+        },
+        q: params[:q].presence,
+        type: params[:type].presence,
+        pagination: { page: page.current_page, total_pages: page.total_pages }
+      }
+    end
+  end
+end

data/app/controllers/rivet_cms/content_types_controller.rb

@@ -1,61 +1,153 @@
 module RivetCms
   class ContentTypesController < ApplicationController
-    before_action :set_content_type, only: [:show, :edit, :update, :destroy]
+    include InertiaProps
+
+    before_action -> { authorize! :read, :schema }, only: [ :index, :show, :trash ]
+    # Restore mirrors removal, gates included: un-removing a type puts its
+    # entries back on the delivery API, so it is no smaller an action.
+    before_action -> { authorize! :delete, :schema }, only: [ :destroy, :purge, :restore ]
+    before_action -> { authorize! :write, :schema }, except: [ :index, :show, :trash, :destroy, :purge, :restore ]
+    before_action :set_content_type, only: [ :show, :update, :destroy ]
+    before_action :set_removed_content_type, only: [ :restore, :purge ]
+    # Purging destroys content, so it needs the content gate as well as schema
+    before_action -> { authorize! :delete, :content }, only: [ :purge ]
+    before_action :authorize_cascade!, only: [ :destroy, :restore ]
+    # Record layer: same gates, about this specific type
+    before_action -> { authorize! :read, :schema, record: @content_type }, only: [ :show ]
+    before_action -> { authorize! :write, :schema, record: @content_type }, only: [ :update ]
+    before_action -> { authorize! :delete, :schema, record: @content_type }, only: [ :destroy, :restore, :purge ]
+    before_action -> { authorize! :delete, :content, record: @content_type }, only: [ :purge ]
 
     def index
-      @content_types = ContentType.order(:name)
+      # Entry counts are content data, not schema; omit them without content read
+      entry_counts = can?(:read, :content) ? Document.where(organization: Current.organization).in_visible_types.group(:content_type_id).count : nil
+
+      render inertia: "ContentTypes/Index", props: {
+        removed_count: ContentType.with_discarded.discarded.where(organization: Current.organization).count,
+        content_types: permitted(Current.organization.content_types, :read, :schema).map { |ct|
+          props = content_type_props(ct)
+          entry_counts ? props.merge(documents_count: entry_counts.fetch(ct.id, 0)) : props
+        }
+      }
     end
 
     def show
-      @contents = @content_type.contents.order(created_at: :desc).limit(10)
-    end
+      fields = @content_type.fields.kept.ordered
 
-    def new
-      @content_type = ContentType.new
+      render inertia: "ContentTypes/Show", props: {
+        content_type: content_type_props(@content_type),
+        fields: fields.map { |f| field_props(f) },
+        field_types: Field::FIELD_TYPE_LABELS,
+        # Selectable targets for "reference" and "component" field options
+        reference_targets: permitted(Current.organization.content_types.where.not(id: @content_type.id).order(:name), :read, :schema).map { |ct| { id: ct.id, name: ct.name } },
+        embeddable_components: permitted(Current.organization.components.order(:name), :read, :schema).map { |c| { id: c.id, name: c.name } }
+      }
     end
 
-    def edit
+    def new
+      render inertia: "ContentTypes/New"
     end
 
     def create
-      @content_type = ContentType.new(content_type_params)
+      content_type = ContentType.new(content_type_params)
 
-      if @content_type.save
-        redirect_to @content_type, notice: 'Content type was successfully created.'
+      if content_type.save
+        audit "content_type.created", content_type
+        redirect_to content_type_path(content_type), notice: "Content type created successfully"
       else
-        respond_to do |format|
-          format.html { render :new, status: :unprocessable_entity }
-          format.turbo_stream { 
-            render turbo_stream: turbo_stream.update("content_type_form",
-              partial: "form",
-              locals: { content_type: @content_type }
-            )
-          }
-        end
+        redirect_to new_content_type_path, inertia: { errors: content_type.errors }
       end
     end
 
     def update
       if @content_type.update(content_type_params)
-        redirect_to @content_type, notice: 'Content type was successfully updated.'
+        audit "content_type.updated", @content_type
+        redirect_to content_type_path(@content_type), notice: "Content type updated successfully"
       else
-        render :edit
+        redirect_to content_type_path(@content_type), inertia: { errors: @content_type.errors }
       end
     end
 
+    # Removed types are kept, so they need somewhere to be seen and restored
+    def trash
+      removed = permitted(ContentType.with_discarded.discarded.where(organization: Current.organization).order(:deleted_at), :read, :schema)
+      entry_counts = can?(:read, :content) ? Document.with_discarded.where(content_type_id: removed.map(&:id)).group(:content_type_id).count : nil
+
+      render inertia: "ContentTypes/Trash", props: {
+        content_types: removed.map { |content_type|
+          props = content_type_props(content_type).merge(
+            removed_at: content_type.deleted_at.iso8601,
+            paths: { restore: restore_content_type_path(content_type), purge: purge_content_type_path(content_type) }
+          )
+          entry_counts ? props.merge(documents_count: entry_counts.fetch(content_type.id, 0)) : props
+        }
+      }
+    end
+
+    def restore
+      @content_type.undiscard!
+      audit "content_type.restored", @content_type
+      redirect_to content_type_path(@content_type), notice: "#{@content_type.name} was restored with its entries"
+    end
+
+    # The one place content is really destroyed. Only reachable from the trash,
+    # and only when the typed name matches, so it cannot be a slip.
+    def purge
+      unless params[:confirm].to_s.strip == @content_type.name.to_s.strip
+        return redirect_back fallback_location: trash_content_types_path, allow_other_host: false,
+                             status: :see_other, alert: "Type the name exactly to permanently delete it"
+      end
+
+      name = @content_type.name
+      ContentType.transaction do
+        # with_discarded: trashed entries still hold the FK and must go too
+        documents = Document.with_discarded.where(content_type_id: @content_type.id)
+        # Incoming links hold a foreign key, so they go before their targets
+        Relation.where(target_document_id: documents.select(:id)).delete_all
+        documents.find_each(&:destroy!)
+        @content_type.destroy!
+      end
+
+      audit "content_type.purged", @content_type
+      # Back to whichever trash (global or scoped) the purge came from
+      redirect_back fallback_location: trash_content_types_path, allow_other_host: false,
+                    status: :see_other, notice: "#{name} and its entries were permanently deleted"
+    rescue ActiveRecord::ActiveRecordError => error
+      Rails.logger&.error("[RivetCms] purge failed for content type #{@content_type.id}: #{error.class}")
+      redirect_back fallback_location: trash_content_types_path, allow_other_host: false,
+                    status: :see_other, alert: "#{name} could not be deleted; nothing was removed"
+    end
+
     def destroy
-      @content_type.destroy
-      redirect_to content_types_url, notice: 'Content type was successfully destroyed.'
+      @content_type.discard!
+      audit "content_type.removed", @content_type
+      # The type's own page dies with the removal; anywhere else goes back
+      redirect_after_trash(content_type_path(@content_type), content_types_path,
+                           notice: "#{@content_type.name} was removed. Its entries are kept and it can be restored from the trash.")
     end
 
     private
 
+    # Removing a type hides its entries from the admin and the delivery API,
+    # so it is a content-level action as well as a schema one.
+    def authorize_cascade!
+      return unless Document.with_discarded.where(content_type_id: @content_type.id).exists?
+
+      # Both phases, like every other gate: recordless first, then the record
+      authorize! :delete, :content
+      authorize! :delete, :content, record: @content_type
+    end
+
+    def set_removed_content_type
+      @content_type = ContentType.with_discarded.discarded.where(organization: Current.organization).find(params[:id])
+    end
+
     def set_content_type
-      @content_type = ContentType.find(params[:id])
+      @content_type = Current.organization.content_types.find(params[:id])
     end
 
     def content_type_params
-      params.require(:content_type).permit(:name, :slug, :description, :is_single)
+      params.require(:content_type).permit(:name, :slug, :description, :single)
     end
   end
-end 
+end