render_turbo_stream 3.0.4 → 4.0.0

data/lib/render_turbo_stream/controller_channel_helpers.rb

@@ -2,6 +2,7 @@ module RenderTurboStream
   module ControllerChannelHelpers
 
     def render_to_all(target_id, action = :replace, partial: nil, template: nil, locals: nil)
+      evaluate_instance_variables
       render_to_channel(
         'all',
         target_id,
@@ -26,7 +27,7 @@ module RenderTurboStream
 
       render_to_channel(
         "authenticated-user-#{helpers.current_user.id}",
-        target_id,
+        RenderTurboStream::Libs.target_id_to_target(target_id),
         action,
         partial: partial,
         locals: locals
@@ -47,23 +48,25 @@ module RenderTurboStream
 
       render_to_channel(
         "authenticated-group-#{group}",
-        target_id,
+        RenderTurboStream::Libs.target_id_to_target(target_id),
         action,
         partial: partial,
         locals: locals
       )
     end
 
-    def render_to_channel(channel, target_id, action, partial: nil, template: nil, locals: nil)
+    def render_to_channel(channel, target_id, action, partial: nil, template: nil, locals: nil, instance_variables: true)
+
+      raise 'Arguments partial and template cannot both be specified' if partial && template
 
       disable_default = false
-      if partial
-        template = nil
-      elsif template.present? && !template.to_s.include?('/')
-        template = [controller_path, template].join('/')
+      if partial.present?
+        _partial = RenderTurboStream::Libs.partial_path(nil, target_id, controller_path, partial)
+      elsif template.present?
+        _template = RenderTurboStream::Libs.partial_path(nil, target_id, controller_path, template)
         disable_default = true
       else
-        template = [controller_path, action_name].join('/')
+        _template = [controller_path, action_name].join('/')
         disable_default = true
       end
 
@@ -73,7 +76,17 @@ module RenderTurboStream
         @render_cable_template_was_called = true
       end
 
-      RenderTurboStream::ChannelLibs.render_to_channel(response, channel, target_id, action, template: template, partial: partial, locals: locals)
+      evaluate_instance_variables
+
+      libs = RenderTurboStream::ChannelLibs.new(response)
+      libs.render_to_channel(
+        channel,
+        RenderTurboStream::Libs.target_id_to_target(target_id),
+        action,
+        self,
+        template: _template,
+        partial: _partial, locals: locals
+      )
 
     end
 
@@ -114,7 +127,86 @@ module RenderTurboStream
     end
 
     def action_to_channel(channel, command, arguments)
-      RenderTurboStream::ChannelLibs.action_to_channel(response, channel, command, arguments)
+      libs = RenderTurboStream::ChannelLibs.new(response)
+      libs.action_to_channel(channel, command, arguments)
+    end
+
+    def turbo_channel_save(
+      save_action,
+      object: nil, # object used in save_action, example: @customer
+
+      if_success_redirect_to: nil, # does a regular redirect. Works if you are inside a turbo_frame and just want to redirect inside that frame BUT CANNOT STREAM OTHERS ACTIONS ON THE SAME RESPONSE https://github.com/rails/rails/issues/48056
+
+      if_success: nil, # hash for a partial to render or array with actions (as array) or hashes for partials within
+      if_error: nil, # additional partials that should be rendered if save_action failed
+      add: [], # additional streams
+
+      if_success_notices: nil, # array of strings, override default generated flash generation in the case of success
+      if_error_alerts: nil,
+      add_notices: nil, # array of strings
+      add_alerts: nil,
+
+      flash_controller_action_name: action_name, # options: 'update', 'create', otherwise you have to declare a translation in config/locales like "activerecord.success.#{flash_controller_action_name}" and "activerecord.errors.#{flash_controller_action_name}"
+      instance_variables: true # options: if false, nothing happens, if true: Instance variables that matching to controller name like @article or @articles are set to locals. By Array you can add more, example: [:my_var]
+    )
+
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      #                    LOGIC
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+      unless object
+        object = eval("@#{controller_name.classify.underscore}")
+      end
+
+      libs = RenderTurboStream::ControllerLibs.new(save_action)
+      model_name = object.model_name.human
+
+      turbo_actions = libs.generate_flash(
+        model_name,
+        flash_controller_action_name,
+        if_success_notices,
+        if_error_alerts,
+        add_notices,
+        add_alerts,
+      )[:turbo_actions]
+
+      turbo_actions += libs.additional_actions(
+        if_success,
+        if_error,
+        add
+      )
+
+      if libs.action_errors(turbo_actions).present?
+        raise libs.action_errors(turbo_actions).join(', ')
+      end
+
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      #==                      RENDER TO CHANNEL
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+      libs = RenderTurboStream::ChannelLibs.new(response)
+      if (helpers.current_user.id rescue false)
+        libs.send_actions_to_channel(
+          "authenticated-user-#{helpers.current_user.id}",
+          turbo_actions,
+          instance_variables: instance_variables
+        )
+      end
+
+      if save_action && if_success_redirect_to.present?
+        response.status = 302
+        redirect_to if_success_redirect_to
+      end
+
+    end
+
+    @render_turbo_stream_evaluate_instance_variables = nil
+
+    def evaluate_instance_variables
+      @render_turbo_stream_evaluate_instance_variables ||= (
+        { var_test: 'alpha' }
+      )
+
     end
 
   end

data/lib/render_turbo_stream/controller_helpers.rb

@@ -2,187 +2,118 @@ module RenderTurboStream
   module ControllerHelpers
 
     # Handles translated flash messages as defined in translations and configs.
-    # If :redirect_on_success_to and channel set up and use_channel_for_turbo_stream_save are configured, sends flash message by channel_to_me.
+    # If :if_success_redirect_to and channel set up and allow_channel_to_me_for_turbo_stream_save are configured, sends flash message by channel_to_me.
     # you can add more stream actions to the same response
 
     def turbo_stream_save(
       save_action,
-      redirect_on_success_to: nil, # does a regular redirect. Works if you are inside a turbo_frame and just want to redirect inside that frame BUT CANNOT STREAM OTHERS ACTIONS ON THE SAME RESPONSE https://github.com/rails/rails/issues/48056
-      turbo_redirect_on_success_to: nil, # does a full page redirect (break out of all frames by turbo_power redirect)
       object: nil, # object used in save_action, example: @customer
-      id: nil, # if nil: no partial is rendered
-      partial: nil, # example: 'customers/form' default: "#{controller_path}/#{id}"
+
+      if_success_redirect_to: nil, # does a regular redirect. Works if you are inside a turbo_frame and just want to redirect inside that frame BUT CANNOT STREAM OTHERS ACTIONS ON THE SAME RESPONSE https://github.com/rails/rails/issues/48056
+      if_success_turbo_redirect_to: nil, # does a full page redirect (break out of all frames by turbo_power redirect)
+
+      target_id: nil, # IF NIL: no partial will be rendered AND IF allowed by config: it would send by channel *_to_me and not affect the default response-rendering
+      partial: nil,
       action: 'replace', # options: append, prepend
-      flash_action: action_name, # options: 'update', 'create', otherwise you have to declare a translation in config/locales like "activerecord.success.#{flash_action}" and "activerecord.errors.#{flash_action}"
-      locals: {}, # locals used by the partial
-      streams_on_success: [
-        {
-          id: nil,
-          partial: 'form',
-          locals: {},
-          action: 'replace'
-        }
-      ], # additional partials that should be rendered if save_action succeeded
-      streams_on_error: [
-        {
-          id: nil,
-          partial: 'form',
-          locals: {},
-          action: 'replace'
-        }
-      ], # additional partials that should be rendered if save_action failed
-      add_flash_alerts: [], #=> array of strings
-      add_flash_notices: [], #=> array of strings
-      flashes_on_success: [], #=> array of strings
-      flashes_on_error: [] #=> array of strings
+      locals: {}, # locals used by the target_id
+
+      if_success: nil, # hash for a partial to render or array with actions (as array) or hashes for partials within
+      if_error: nil, # additional partials that should be rendered if save_action failed
+      add: [], # additional streams
+
+      if_success_notices: nil, # array of strings, override default generated flash generation in the case of success
+      if_error_alerts: nil,
+      add_notices: nil, # array of strings
+      add_alerts: nil,
+
+      flash_controller_action_name: action_name # options: 'update', 'create', otherwise you have to declare a translation in config/locales like "activerecord.success.#{flash_controller_action_name}" and "activerecord.errors.#{flash_controller_action_name}"
     )
 
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      #                    EXCEPTIONS
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+      raise 'render_turbo_stream: arguments target_id and if_success_redirect_to cannot be provided both' if target_id && if_success_redirect_to
+
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      #                    LOGIC
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
       unless object
         object = eval("@#{controller_name.classify.underscore}")
       end
 
-      #== Streams / Partials
+      libs = RenderTurboStream::ControllerLibs.new(save_action)
+      model_name = object.model_name.human
 
-      streams = (id ? [id: id, partial: partial, locals: locals, action: action] : [])
+      streams = (target_id ? libs.generate_action(controller_path, target_id, action, partial, locals) : [])
+
+      flashes = libs.generate_flash(
+        model_name,
+        flash_controller_action_name,
+        if_success_notices,
+        if_error_alerts,
+        add_notices,
+        add_alerts,
+        )
+      streams += flashes[:turbo_actions]
+
+      streams += libs.additional_actions(
+        if_success,
+        if_error,
+        add
+      )
 
-      if save_action
-        response.status = 200
-        streams_on_success.each do |s|
-          if s.is_a?(Array)
-            streams.push(s)
-          elsif s.is_a?(Hash) && s[:id].present?
-            streams.push(s)
-          end
-        end
-      else
-        response.status = :unprocessable_entity
-        streams += streams_on_error.select { |s| s[:id].present? }
+      if libs.action_errors(streams).present?
+        raise libs.action_errors(streams).join(', ')
       end
 
-      #== FLASHES
-
-      model_name = object.model_name.human
-      if save_action
-        flash_notices = if flashes_on_success.present?
-                          flashes_on_success
-                        elsif flash_action.to_s == 'create'
-                          str = I18n.t(
-                            'activerecord.success.successfully_created',
-                            default: '%<model_name>s successfully created'
-                          )
-                          [format(str, model_name: model_name)]
-                        elsif flash_action.to_s == 'update'
-                          str = I18n.t(
-                            'activerecord.success.successfully_updated',
-                            default: '%<model_name>s successfully updated'
-                          )
-                          [format(str, model_name: model_name)]
-                        else
-                          str = I18n.t(
-                            "activerecord.success.#{flash_action}",
-                            default: '%<model_name>s successfully updated'
-                          )
-                          [format(str, model_name: model_name)]
-                        end
-        flash_alerts = []
-      else
-        flash_alerts = if flashes_on_error.present?
-                         flashes_on_error
-                       elsif flash_action.to_s == 'create'
-                         str = I18n.t(
-                           'activerecord.errors.messages.could_not_create',
-                           default: '%<model_name>s could not be created'
-                         )
-                         [format(str, model_name: model_name)]
-                       elsif flash_action.to_s == 'update'
-                         str = I18n.t(
-                           'activerecord.errors.messages.could_not_update',
-                           default: '%<model_name>s could not be updated'
-                         )
-                         [format(str, model_name: model_name)]
-                       else
-                         str = I18n.t(
-                           "activerecord.errors.messages.#{flash_action}",
-                           default: '%<model_name>s could not be updated'
-                         )
-                         [format(str, model_name: model_name)]
-                       end
-        flash_notices = []
+      unless save_action
+        response.status = 422
       end
 
-      flash_notices += add_flash_notices.to_a
-      flash_alerts += add_flash_alerts.to_a
-      _flash_id = Rails.configuration.x.render_turbo_stream.flash_id
-      flash_id = (_flash_id ? _flash_id : "ERROR, MISSING CONFIG => config.x.render_turbo_stream.flash_id")
-      flash_partial = Rails.configuration.x.render_turbo_stream.flash_partial
-      flash_action = Rails.configuration.x.render_turbo_stream.flash_action
-      flash_notices.each do |notice|
-        next unless notice.present?
-        # inside the flash partial has to be a loop that handles all theese flashes
-        flash_stream = {
-          id: flash_id,
-          partial: flash_partial,
-          action: flash_action,
-          locals: { success: true, message: notice }
-        }
-        streams.push(flash_stream)
-      end
-      flash_alerts.each do |alert|
-        next unless alert.present?
-        # inside the flash partial has to be a loop that handles all theese flashes
-        flash_stream = {
-          id: flash_id,
-          partial: flash_partial,
-          action: flash_action,
-          locals: { success: false, message: alert }
-        }
-        streams.push(flash_stream)
-      end
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      #==                      RENDER TO STREAM
+      # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
-      #== render
+      allow_channel = (Rails.configuration.x.render_turbo_stream.allow_channel_to_me_for_turbo_stream_save rescue false) && (helpers.current_user.id.present? rescue false)
 
-      if save_action && turbo_redirect_on_success_to.present?
+      if save_action && if_success_turbo_redirect_to.present?
         response.status = 302
-        flash[:alert] = flash_alerts
-        flash[:notice] = flash_notices
-        Rails.logger.debug("  • Set flash[:alert] => #{flash_alerts}") if flash_alerts.present?
-        Rails.logger.debug("  • Set flash[:notice] => #{flash_notices}") if flash_notices.present?
+        flash[:alert] = flashes[:alerts]
+        flash[:notice] = flashes[:notices]
+        Rails.logger.debug("  • Set flash[:alert] => #{flashes[:alerts]}") if flashes[:alerts].present?
+        Rails.logger.debug("  • Set flash[:notice] => #{flashes[:notices]}") if flashes[:notices].present?
         render_turbo_stream([
                               [
                                 :redirect_to,
-                                turbo_redirect_on_success_to
+                                if_success_turbo_redirect_to
                               ]
                             ])
-      elsif save_action && redirect_on_success_to.present?
+      elsif save_action && if_success_redirect_to.present?
         response.status = 302
-        if (Rails.configuration.x.render_turbo_stream.use_channel_for_turbo_stream_save rescue false) && (helpers.current_user.id.present? rescue false)
-          streams.each do |s|
-            next unless s.is_a?(Hash)
-            Rails.logger.debug("  • Send by Cable => «#{s}»")
-            render_to_me(
-              s[:id],
-              flash_action,
-              partial: s[:partial],
-              locals: s[:locals]
-            )
-          end
-
+        if allow_channel
+          Rails.logger.debug("  • Sent #{streams.length} actions through Turbo::StreamsChannel to enable defined redirection because allowed in configs.")
+          c_libs = RenderTurboStream::ChannelLibs.new(response)
+          c_libs.send_actions_to_channel("authenticated-user-#{helpers.current_user.id}", streams, @render_turbo_stream_evaluate_instance_variables)
         else
           flash[:alert] = flash_alerts
           flash[:notice] = flash_notices
           Rails.logger.debug("  • Set flash[:alert] => #{flash_alerts}") if flash_alerts.present?
           Rails.logger.debug("  • Set flash[:notice] => #{flash_notices}") if flash_notices.present?
         end
-        redirect_to redirect_on_success_to
+        redirect_to if_success_redirect_to
+
+      elsif !target_id.present? && allow_channel
+        Rails.logger.debug("  • Sent #{streams.length} actions through Turbo::StreamsChannel because no target_id defined and allowed in configs.")
+        c_libs = RenderTurboStream::ChannelLibs.new(response)
+        c_libs.send_actions_to_channel("authenticated-user-#{helpers.current_user.id}", streams, @render_turbo_stream_evaluate_instance_variables)
 
       else
-        flash.now[:alert] = flash_alerts
-        flash.now[:notice] = flash_notices
         render_turbo_stream(streams)
       end
     end
 
-
     # renders a array of partials to send by turbo-stream and / or actions like turbo_power gem includes, to turbo_stream
     def render_turbo_stream(array)
 
@@ -192,12 +123,12 @@ module RenderTurboStream
           Rails.logger.warn "  WARNING render_turbo_stream: Empty element inside attributes: «#{array}»"
         elsif pr.is_a?(Hash)
           props = pr.symbolize_keys
-          raise "missing attribute :id in #{props}" if !props[:id].present?
-          part = (props[:partial].present? ? props[:partial] : props[:id]).gsub('-', '_')
-          partial = (part.to_s.include?('/') ? part : [controller_path, part].join('/'))
           r = props
+          r[:target] = RenderTurboStream::Libs.target_id_to_target(props[:target_id]) if props[:target_id].present?
+          raise "Missing attribute :target in #{props}" if !props[:target].present?
+          r.delete(:target_id)
           r[:action] = (props[:action].present? ? props[:action] : :replace)
-          r[:partial] = partial
+          r[:partial] = RenderTurboStream::Libs.partial_path(props[:target], props[:target_id], controller_path, props[:partial])
           r[:type] = 'stream-partial'
           ary.push(r)
         elsif pr.is_a?(Array)
@@ -219,16 +150,11 @@ module RenderTurboStream
 
     # renders a partial to turbo_stream
 
-    def stream_partial(
-      id,
-      partial: nil, #=> default: id
-      action: :replace,
-      locals: {}
-    )
+    def stream_partial( target_id, partial: nil, action: :replace, locals: {} )
       render_turbo_stream(
         [
           {
-            id: id,
+            target: RenderTurboStream::Libs.target_id_to_target(target_id),
             partial: partial,
             action: action,
             locals: locals

data/lib/render_turbo_stream/controller_libs.rb

@@ -0,0 +1,162 @@
+module RenderTurboStream
+  class ControllerLibs
+
+    def initialize(save_action)
+      @save_action = save_action
+    end
+
+    def generate_flash( model_name, controller_action, if_success_notices, if_error_alerts, add_notices, add_alerts )
+
+      target_id = (Rails.configuration.x.render_turbo_stream.flash_target_id rescue nil)
+      raise "Missing configuration: config.x.render_turbo_stream.flash_target_id" unless target_id
+      partial = Rails.configuration.x.render_turbo_stream.flash_partial
+      raise "Missing configuration: configuration.x.render_turbo_stream.flash_partial" unless partial
+      turbo_action = Rails.configuration.x.render_turbo_stream.flash_turbo_action
+      raise "Missing configuration: configuration.x.render_turbo_stream.flash_turbo_action" unless turbo_action
+
+
+      if @save_action
+        notices = if if_success_notices
+                          if_success_notices
+                        elsif controller_action.to_sym == :create
+                          str = I18n.t(
+                            'activerecord.success.successfully_created',
+                            default: '%<model_name>s successfully created'
+                          )
+                          [format(str, model_name: model_name)]
+                        elsif controller_action.to_sym == :update
+                          str = I18n.t(
+                            'activerecord.success.successfully_updated',
+                            default: '%<model_name>s successfully updated'
+                          )
+                          [format(str, model_name: model_name)]
+                        else
+                          str = I18n.t(
+                            "activerecord.success.#{controller_action}",
+                            default: '%<model_name>s successfully updated'
+                          )
+                          [format(str, model_name: model_name)]
+                        end
+        alerts = []
+      else
+        alerts = if if_error_alerts
+                         if_error_alerts
+                       elsif controller_action.to_sym == :create
+                         str = I18n.t(
+                           'activerecord.errors.messages.could_not_create',
+                           default: '%<model_name>s could not be created'
+                         )
+                         [format(str, model_name: model_name)]
+                       elsif controller_action.to_sym == :update
+                         str = I18n.t(
+                           'activerecord.errors.messages.could_not_update',
+                           default: '%<model_name>s could not be updated'
+                         )
+                         [format(str, model_name: model_name)]
+                       else
+                         str = I18n.t(
+                           "activerecord.errors.messages.#{controller_action}",
+                           default: '%<model_name>s could not be updated'
+                         )
+                         [format(str, model_name: model_name)]
+                       end
+        notices = []
+      end
+
+      turbo_actions = []
+      notices += add_notices.to_a
+      alerts += add_alerts.to_a
+      notices.each do |notice|
+        next unless notice.present?
+        flash_stream = {
+          target: RenderTurboStream::Libs.target_id_to_target(target_id),
+          partial: partial,
+          action: turbo_action,
+          locals: { success: true, message: notice }
+        }
+        turbo_actions.push(flash_stream)
+      end
+      alerts.each do |alert|
+        next unless alert.present?
+        flash_stream = {
+          target: RenderTurboStream::Libs.target_id_to_target(target_id),
+          partial: partial,
+          action: turbo_action,
+          locals: { success: false, message: alert }
+        }
+        turbo_actions.push(flash_stream)
+      end
+      { turbo_actions: turbo_actions, alerts: alerts, notices: notices }
+    end
+
+    def additional_actions( if_success, if_error, add )
+
+      (@save_action ? make_actions(if_success) : make_actions(if_error)) + make_actions(add)
+
+    end
+
+    def generate_action( controller_path, target_id, action, partial, locals )
+      libs = RenderTurboStream::Libs
+      target = libs.target_id_to_target(target_id)
+      _partial = libs.partial_path(nil, target_id, controller_path, partial)
+      [target: target, partial: _partial, locals: locals, action: action]
+    end
+
+    def action_errors(actions)
+      r = []
+      actions.each do |a|
+        if a.is_a?(Hash)
+          unless a[:target].present?
+            r.push("Missing attribute :target for => «#{a}»")
+          end
+          unless a[:partial].present?
+            r.push("Missing attribute :partial for => «#{a}»")
+          end
+          unless a[:action].present?
+            r.push("Missing attribute :action for => «#{a}»")
+          end
+        elsif a.is_a?(Array)
+          unless a.first.is_a?(String) || a.first.is_a?(Symbol)
+            r.push("Assuming a command, but the first attribute must be a string or symbol => «#{a}»")
+          end
+        end
+      end
+      r
+    end
+
+    private
+
+    # streamline actions to array
+    # valid inputs for if_success or if_error or add
+    # [:add_css_class, ...]
+    # [[:add_css_class, ..], ..]
+    # {target_id: '..', ..}
+    # [{target_id: '..', ..}, ..]
+
+    def make_actions(actions)
+      res = if actions.present?
+              if actions.is_a?(Hash)
+                [actions]
+              elsif actions.is_a?(Array)
+                if actions.first.is_a?(String) || actions.first.is_a?(Symbol)
+                  [actions]
+                else
+                  actions
+                end
+              end
+            else
+              []
+            end
+      res.map do |a|
+        if a.is_a?(Hash) && a.key?(:target_id)
+          a = a.merge(target: "##{a[:target_id]}")
+          a.delete(:target_id)
+          a
+        else
+          a
+        end
+      end
+    end
+
+  end
+end

data/lib/render_turbo_stream/libs.rb

@@ -0,0 +1,35 @@
+module RenderTurboStream
+  class Libs
+
+    def self.target_id_to_target(target_id)
+      if target_id.present?
+        "##{target_id}"
+      else
+        nil
+      end
+    end
+
+    def self.target_to_target_id(target)
+      if target.present? && target.to_s[0] == '#'
+        target[1..-1]
+      else
+        nil
+      end
+    end
+
+    def self.partial_path(target, target_id, controller_path, partial)
+      if partial && partial.to_s.include?('/')
+        partial
+      elsif partial.present?
+        [controller_path, partial].join('/')
+      elsif target_id.present?
+        [controller_path, target_id.gsub('-', '_')].join('/')
+      elsif target.present?
+        [controller_path, RenderTurboStream::Libs.target_to_target_id(target).gsub('-', '_')].join('/')
+      end
+    end
+
+
+
+  end
+end