rdux 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9466995069583a72d2327967aebfa05218c2c224aa091645dbee874e53a491f
-  data.tar.gz: e1ec237a0de458512951e68f29596b0677a45d56b417d4b139ee4aa6a79bea13
+  metadata.gz: 7d08bba313e7358c9ab679919bffa752086205e61c3884285da3cca786b1c63e
+  data.tar.gz: 6aa632159bdc20f99fb82686374bc0cf72359a08219485168d5be3fe2e4441bc
 SHA512:
-  metadata.gz: f1eec1d56443a217a827f9cfc6d30bbcc0d0ab4fb68dc912cbf9ac4986342e91de660e4876ce7d3bbf67493905be10edd5b2a07fa2056d110fe118f2f5e68892
-  data.tar.gz: 799a77dd6396597790ca62b27cc203fa4b529935a486d6136645bc64d8759801b844c918f863e990a1e06cd973c4b02184da100d496a1439a3c957c34f4a3581
+  metadata.gz: 6420dd96aa5f4c5f51e8bd4ef1d5b689892a7693405b5f27045bbaa5af57a8c09237a9213eb30a85907d7fd7bd4af926c85494843ff32d0330f36dc39c8e375e
+  data.tar.gz: 873fe11556fff66df5290cb3f9aaa9414c39d28299b2f8a1a207a5351853de70e5801fd8d654d9022d1864a243eab4b12f2727be6d866ce7731877d96727a712

data/README.md

@@ -49,7 +49,7 @@ $ bin/rails rdux:install:migrations
 $ bin/rails db:migrate
 ```
 
-⚠️ Note: Rdux uses `JSONB` datatype instead of `text` for Postgres.
+⚠️ Note: Rdux requires Rails 7.1+. It uses `jsonb` columns on PostgreSQL and `json` on other adapters.
 
 ## 🎮 Usage
 
@@ -60,7 +60,7 @@ To dispatch an action using Rdux, use the `dispatch` method (aliased as `perform
 Definition:
 
 ```ruby
-def dispatch(action, payload, opts = {}, meta: nil)
+def dispatch(action, payload, opts: {}, meta: nil)
 
 alias perform dispatch
 ```
@@ -78,7 +78,7 @@ Example:
 Rdux.perform(
   Task::Create,
   { task: { name: 'Foo bar baz' } },
-  { ars: { user: current_user } },
+  opts: { ars: { user: current_user } },
   meta: { bar: 'baz' }
 )
 ```
@@ -89,7 +89,7 @@ Rdux.perform(
 
 ### 🕵️‍♀️ Processing an action
 
-Action in Rdux is processed by an action performer which is a Plain Old Ruby Object (PORO) that implements a class or instance method `call`.
+Action in Rdux is processed by an action performer which is a Plain Old Ruby Object (PORO) that implements the `self.call` method.
 This method accepts a required `payload` and an optional `opts` argument.
 `opts[:action]` stores the Active Record object.
 `call` method processes the action and must return a `Rdux::Result` struct.
@@ -102,8 +102,8 @@ Example:
 # app/actions/task/create.rb
 
 class Task
-  class Create
-    def call(payload, opts)
+  module Create
+    def self.call(payload, opts)
       user = opts.dig(:ars, :user) || User.find(payload['user_id'])
       task = user.tasks.new(payload['task'])
       if task.save
@@ -269,7 +269,7 @@ class CreditCard
       private
 
       def create(payload, opts)
-        res = Rdux.perform(Create, payload, opts)
+        res = Rdux.perform(Create, payload, opts:)
         res.ok ? res : Rdux::Result[ok: false, val: { errors: res.val[:errors] }, save: true]
       end
     end
@@ -277,6 +277,191 @@ class CreditCard
 end
 ```
 
+### 🧹 Development Mode
+
+Set the `RDUX_DEV` environment variable to prevent Rdux from persisting failed actions on exceptions. When `RDUX_DEV` is set, the action record is destroyed and the exception is re-raised without storing error details in the database.
+
+```bash
+RDUX_DEV=1 bin/rails server
+```
+
+This keeps your development database clean from failed action records caused by exceptions during iterative development.
+
+## 🧩 Process
+
+**Process** 👉 a series of actions or steps taken in order to achieve a particular end.
+
+`Rdux::Process` is a persisted model that groups multiple `Rdux::Action`s.
+It also stores an ordered list of `steps` (`jsonb`/`json`).
+
+When a process starts:
+
+* Steps run **sequentially** in the order defined in `STEPS`
+* Process execution continues only when the latest process action returns `ok: true`
+* Execution stops on the first failed action step (`ok == false`)
+* `process.ok` is persisted from the latest non-`nil` step result
+
+Key points:
+
+* `Rdux::Process` **has many** `Rdux::Action`s (`process.actions`)
+* `Rdux::Action` **belongs to** a process (`action.process`)
+* `Rdux.start(ProcessModuleOrClass, payload)` starts a process performer (a PORO namespace/class with a `STEPS` constant)
+* `STEPS` must be an `Array` (validated on `Rdux::Process`)
+* `steps` is stored as `jsonb` on PostgreSQL and `json` on other adapters (default: `[]`)
+* `STEPS` supports:
+  * a step definition hash (`{ name: User::Create, payload: ->(payload, prev_res) { ... } }`)
+  * a callable step (`->(payload, process) { ... }`)
+* For hash steps, Rdux dispatches `Rdux.perform(step_name, step_payload, process: process)` (`step_payload` is the full process payload unless `payload:` proc is provided)
+* For callable steps, Rdux calls the step with `(safe_payload, process)` and the step is responsible for dispatching an action (with `Rdux.perform(..., process:)`)
+  * ⚠️ If a step returns `ok: false`, that step action is persisted (and can be assigned to the process) **only** when it also returns `save: true`. This is required.
+* Inside an action performer, use `opts[:action]` to access the current persisted action, then traverse `opts[:action].process.actions` (and their `result`)
+* Actions dispatched *inside* an action performer (via `Rdux.perform`) are linked via `rdux_action_id` (`action.rdux_actions`) and are not automatically assigned to the process
+
+Example:
+
+```ruby
+module Processes
+  module Subscription
+    module Create
+      STEPS = [
+        lambda { |payload, process|
+          payload = payload.slice('plan_id', 'user', 'total_cents')
+          Rdux.perform(::Subscription::Preview, payload, process:)
+        },
+        lambda { |payload, process|
+          payload = payload.slice('user')
+          Rdux.perform(User::Create, payload, process:)
+        },
+        { name: CreditCard::Create,
+          payload: lambda { |payload, prev_res|
+            payload.slice('credit_card').merge(user_id: prev_res.action.result['user_id'])
+          } },
+        { name: Payment::Create,
+          payload: ->(_, prev_res) { { token: prev_res.val[:credit_card].token } } },
+        { name: ::Subscription::Create,
+          payload: ->(payload, prev_res) { payload.slice('plan_id').merge(ext_charge_id: prev_res.val[:charge_id]) } }
+      ].freeze
+    end
+  end
+end
+
+res = Rdux.start(Processes::Subscription::Create, payload)
+process = res.val[:process]
+
+# from any action performer:
+def self.call(payload, opts)
+  results = opts[:action].process.actions.order(:id).pluck(:result)
+  # ...
+end
+```
+
+## 🛠️ Helpers
+
+### `ActionResult`
+
+`ActionResult` is not part of Rdux itself, but a useful helper you can copy into your app to persist DB changes and resource relations alongside an action.
+
+It sets `action.result` with:
+
+* `relations` — a map of `"model_name#id" => id` (or raw hashes) for each resource that was modified or created
+* `db_changes` — `saved_changes` for each resource that was modified or created
+* any extra key/value pairs passed as keyword arguments
+
+It also creates an `ActionResource` record for each AR resource, linking it to the action via a polymorphic association.
+
+**Usage:**
+
+```ruby
+# inside an action performer
+opts[:action].result = ActionResult.call(
+  action: opts[:action],
+  resources: [task]
+)
+
+# action.result stored in DB:
+# {
+#   "relations"  => { "task#1" => 1 },
+#   "db_changes" => {
+#     "task#1" => {
+#       "id"         => [nil, 1],
+#       "name"       => [nil, "Foo bar baz"],
+#       "user_id"    => [nil, 42],
+#       "created_at" => [nil, "2024-06-28 21:35:36"],
+#       "updated_at" => [nil, "2024-06-28 21:35:36"]
+#     }
+#   }
+# }
+```
+
+Resources can be ActiveRecord objects or plain hashes (merged directly into `relations`):
+
+```ruby
+ActionResult.call(
+  action: opts[:action],
+  resources: [task, { user_id: user.id }],
+  additional_info: 'Foo Bar Baz'
+)
+```
+
+**`ActionResource` model** (`app/models/action_resource.rb`):
+
+```ruby
+class ActionResource < ApplicationRecord
+  belongs_to :action, class_name: 'Rdux::Action'
+  belongs_to :resource, polymorphic: true
+
+  validates :action_id, uniqueness: { scope: %i[resource_type resource_id] }
+  validates :resource_type, presence: true
+end
+```
+
+**`ActionResult` service** (`app/services/action_result.rb`):
+
+```ruby
+class ActionResult
+  class << self
+    def call(action:, resources:, **custom)
+      result = { relations: {}, db_changes: {} }
+
+      resources.each do |resource|
+        if resource.is_a?(Hash)
+          result[:relations].merge!(resource)
+          next
+        end
+
+        key = relation_key(resource)
+        result[:relations][key] = resource.id
+        result[:db_changes][key] = resource.saved_changes if resource.saved_changes.present?
+      end
+
+      persist_relations(result[:relations], action.id)
+      result.merge(custom)
+    end
+
+    private
+
+    def relation_key(resource)
+      "#{resource.class.name.underscore}##{resource.id}"
+    end
+
+    def resource_type_for(name)
+      type = name.sub(/_id$/, '').sub(/#\d+$/, '').camelize
+      resource_class = type.safe_constantize
+      resource_class && resource_class < ApplicationRecord ? type : nil
+    end
+
+    def persist_relations(relations, action_id)
+      relations.each do |name, id|
+        resource_type = resource_type_for(name)
+        next if resource_type.nil? || !id.to_s.match?(/\A\d+\z/)
+
+        ActionResource.create!(action_id:, resource_type:, resource_id: id)
+      end
+    end
+  end
+end
+```
+
 ## 👩🏽‍🔬 Testing
 
 ### 💉 Setup

data/app/models/concerns/rdux/safe_payload.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rdux
+  module SafePayload
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :payload_unsanitized
+    end
+
+    def only_sanitized_payload?
+      payload_sanitized && payload_unsanitized.nil?
+    end
+
+    def safe_payload
+      payload_unsanitized || payload
+    end
+  end
+end

data/app/models/rdux/action.rb

@@ -4,26 +4,25 @@ module Rdux
   class Action < ActiveRecord::Base
     self.table_name_prefix = 'rdux_'
 
-    attr_accessor :payload_unsanitized
+    include SafePayload
 
     belongs_to :rdux_action, optional: true, class_name: 'Rdux::Action'
+    belongs_to :process, optional: true, class_name: 'Rdux::Process', foreign_key: 'rdux_process_id'
     has_many :rdux_actions, class_name: 'Rdux::Action', foreign_key: 'rdux_action_id'
 
-    if ActiveRecord::Base.connection.adapter_name != 'PostgreSQL'
-      serialize :payload, coder: JSON
-      serialize :result, coder: JSON
-      serialize :meta, coder: JSON
-    end
-
     validates :name, presence: true
     validates :payload, presence: true
 
     scope :ok, ->(val = true) { where(ok: val) }
     scope :failed, -> { where(ok: false) }
 
+    def process_defined?
+      has_attribute?(:rdux_process_id) && rdux_process_id
+    end
+
     def call(opts = {})
       return false if performed?
-      return false if payload_sanitized && payload_unsanitized.nil?
+      return false if only_sanitized_payload?
 
       opts.merge!(action: self)
       perform_action(opts)
@@ -35,23 +34,14 @@ module Rdux
       !ok.nil?
     end
 
-    def action_performer
-      name_const = name.to_s.constantize
-      return name_const if name_const.respond_to?(:call)
-      return unless name_const.is_a?(Class)
-
-      obj = name_const.new
-      obj.respond_to?(:call) ? obj : nil
-    end
-
     def perform_action(opts)
-      performer = action_performer
+      performer = name.to_s.constantize
       return if performer.nil?
 
       if performer.method(:call).arity.abs == 2
-        performer.call(payload_unsanitized || payload, opts)
+        performer.call(safe_payload, opts)
       else
-        performer.call(payload_unsanitized || payload)
+        performer.call(safe_payload)
       end
     end
   end

data/app/models/rdux/process.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Rdux
+  class Process < ActiveRecord::Base
+    self.table_name_prefix = 'rdux_'
+
+    include SafePayload
+
+    has_many :actions, class_name: 'Rdux::Action', foreign_key: 'rdux_process_id', inverse_of: :process,
+                       dependent: :nullify
+
+    validates :name, presence: true
+    validates :payload, presence: true
+    validate :steps_must_be_array
+
+    before_validation on: :create do
+      self.steps = performer::STEPS.map { _1.is_a?(Hash) ? _1[:name] : _1 }
+    end
+
+    def resume(res)
+      return res unless res.ok
+
+      ok_actions_count = 0
+      if res.val != :start
+        ok_actions_count = actions.ok.count
+        update!(ok: true) && return if ok_actions_count == steps.size
+      end
+
+      call_step(index: ok_actions_count, prev_res: res)
+    end
+
+    private
+
+    def steps_must_be_array
+      if !steps.is_a?(Array)
+        errors.add(:steps, 'must be an Array')
+      elsif steps.empty?
+        errors.add(:steps, 'must include at least 1 step')
+      end
+    end
+
+    def performer
+      name.constantize
+    end
+
+    def action_payload(step_def:, prev_res:)
+      step_def[:payload].is_a?(Proc) ? step_def[:payload].call(safe_payload, prev_res) : safe_payload
+    end
+
+    def call_step(index:, prev_res: nil)
+      step_def = performer::STEPS[index]
+      if steps[index].is_a?(Hash)
+        step_def.call(safe_payload, self)
+        return Rdux::Result[ok: nil]
+      end
+
+      action_payload = action_payload(step_def:, prev_res:)
+      Rdux.perform(steps[index], action_payload, process: self)
+    end
+  end
+end

data/db/migrate/20230621215718_create_rdux_actions.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 class CreateRduxActions < ActiveRecord::Migration[7.0]
+  include Rdux::MigrationHelpers
+
   def change
     create_table :rdux_actions do |t|
       t.string :name, null: false
-      t.column :payload, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text), null: false
+      t.column :payload, json_column_type, null: false
       t.boolean :payload_sanitized, default: false, null: false
-      t.column :result, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
-      t.column :meta, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
+      t.column :result, json_column_type
+      t.column :meta, json_column_type
       t.column :ok, :boolean
 
       t.belongs_to :rdux_action, index: true, foreign_key: true

data/db/migrate/20260109000000_create_rdux_processes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateRduxProcesses < ActiveRecord::Migration[7.0]
+  include Rdux::MigrationHelpers
+
+  def change
+    create_table :rdux_processes do |t|
+      t.string :name, null: false
+      t.boolean :ok
+      t.column :steps, json_column_type,
+               null: false,
+               default: []
+      t.column :payload, json_column_type, null: false
+      t.boolean :payload_sanitized, default: false, null: false
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260109000001_add_rdux_process_to_rdux_actions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddRduxProcessToRduxActions < ActiveRecord::Migration[7.0]
+  def change
+    add_reference :rdux_actions, :rdux_process, index: true, foreign_key: { to_table: :rdux_processes }
+  end
+end

data/lib/rdux/dispatching.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Rdux
+  module Dispatching
+    def dispatch(name, payload, opts_arg = {}, opts: nil, meta: nil, process: nil) # rubocop:disable Metrics/ParameterLists
+      opts ||= opts_arg
+      action = store(name, payload, ars: opts.delete(:ars), meta:, process:)
+      process(action, opts.merge(process:))
+    end
+
+    def store(name, payload, ars: nil, meta: nil, process: nil)
+      (ars || {}).each { |k, v| payload["#{k}_id"] = v.id }
+      action = Action.new(name:, payload:, meta:)
+      action.process = process if process
+      Sanitize.call(action)
+      action
+    end
+
+    def process(action, opts = {})
+      res = action.call(opts)
+      return res if destroy_action(res, action)
+
+      assign_to_action(res, action)
+      persist(res, action)
+      resume_process(action, res)&.tap { return _1 }
+
+      res
+    rescue StandardError => e
+      handle_exception(e, action)
+    end
+
+    alias perform dispatch
+
+    private
+
+    def destroy_action(res, action)
+      return false if res.ok || res.save
+      return false if action.process_defined?
+
+      action.destroy
+    end
+
+    def assign_to_action(res, action)
+      action.ok = res.ok
+      return unless res.result
+
+      action.result ||= {}
+      action.result.merge!(res.result)
+    end
+
+    def persist(res, action)
+      res.action = action.tap(&:save!)
+      res.nested&.each { |nested_res| action.rdux_actions << nested_res.action }
+    end
+
+    def resume_process(action, res)
+      return unless action.ok
+      return unless action.process_defined?
+
+      action.process.resume(res)
+    end
+
+    def handle_exception(exc, action)
+      raise(action.destroy && exc) if ENV['RDUX_DEV']
+
+      action.ok = false
+      action.result ||= {}
+      action.result.merge!({ 'Exception' => {
+                             class: exc.class.name,
+                             message: exc.message
+                           } })
+      action.save!
+      raise exc
+    end
+  end
+end

data/lib/rdux/migration_helpers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rdux
+  module MigrationHelpers
+    private
+
+    def json_column_type
+      connection.adapter_name == 'PostgreSQL' ? :jsonb : :json
+    end
+  end
+end

data/lib/rdux/processing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rdux
+  module Processing
+    def start(performer, payload)
+      process = Process.new(name: performer, payload:)
+      Sanitize.call(process)
+      res = process.resume(Rdux::Result[ok: true, val: :start])
+      process.update!(ok: res.ok) unless res.ok.nil?
+      Result[ok: res.ok, val: { process: }]
+    end
+  end
+end

data/lib/rdux/sanitize.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rdux
+  module Sanitize
+    def self.call(aro)
+      param_filter = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+      payload_sanitized = param_filter.filter(aro.payload)
+      aro.payload_sanitized = aro.payload != payload_sanitized
+      aro.payload_unsanitized = aro.payload if aro.payload_sanitized
+      aro.payload = payload_sanitized
+      aro.save! if aro.changed?
+    end
+  end
+end

data/lib/rdux/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rdux
-  VERSION = '2.0.1'
+  VERSION = '3.0.0'
 end

data/lib/rdux.rb

@@ -1,65 +1,13 @@
 # frozen_string_literal: true
 
 require 'rdux/engine'
-require 'rdux/store'
+require 'rdux/migration_helpers'
 require 'rdux/result'
-require 'active_support/concern'
+require 'rdux/sanitize'
+require 'rdux/dispatching'
+require 'rdux/processing'
 
 module Rdux
-  class << self
-    def dispatch(name, payload, opts = {}, meta: nil)
-      action = store(name, payload, ars: opts[:ars], meta:)
-      process(action, opts)
-    end
-
-    def store(name, payload, ars: nil, meta: nil)
-      (ars || {}).each { |k, v| payload["#{k}_id"] = v.id }
-      Store.call(name, payload, meta)
-    end
-
-    def process(action, opts = {})
-      res = action.call(opts)
-      return res if destroy_action(res, action)
-
-      assign_to_action(res, action)
-      persist(res, action)
-      res
-    rescue StandardError => e
-      handle_exception(e, action)
-    end
-
-    alias perform dispatch
-
-    private
-
-    def destroy_action(res, action)
-      return false if res.ok || res.save
-
-      action.destroy
-    end
-
-    def assign_to_action(res, action)
-      action.ok = res.ok
-      return unless res.result
-
-      action.result ||= {}
-      action.result.merge!(res.result)
-    end
-
-    def persist(res, action)
-      res.action = action.tap(&:save!)
-      res.nested&.each { |nested_res| action.rdux_actions << nested_res.action }
-    end
-
-    def handle_exception(exc, action)
-      action.ok = false
-      action.result ||= {}
-      action.result.merge!({ 'Exception' => {
-                             class: exc.class.name,
-                             message: exc.message
-                           } })
-      action.save!
-      raise exc
-    end
-  end
+  extend Dispatching
+  extend Processing
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdux
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Zbigniew Humeniuk
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -98,12 +98,19 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/models/concerns/rdux/safe_payload.rb
 - app/models/rdux/action.rb
+- app/models/rdux/process.rb
 - db/migrate/20230621215718_create_rdux_actions.rb
+- db/migrate/20260109000000_create_rdux_processes.rb
+- db/migrate/20260109000001_add_rdux_process_to_rdux_actions.rb
 - lib/rdux.rb
+- lib/rdux/dispatching.rb
 - lib/rdux/engine.rb
+- lib/rdux/migration_helpers.rb
+- lib/rdux/processing.rb
 - lib/rdux/result.rb
-- lib/rdux/store.rb
+- lib/rdux/sanitize.rb
 - lib/rdux/version.rb
 homepage: https://github.com/artofcodelabs/rdux
 licenses:
@@ -117,14 +124,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.2
+      version: 3.3.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A Minimal Event Sourcing Plugin for Rails
 test_files: []

data/lib/rdux/store.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Rdux
-  module Store
-    class << self
-      def call(name, payload, meta)
-        action = Action.new(name:, payload:, meta:)
-        sanitize(action)
-        action.save!
-        action
-      end
-
-      private
-
-      def sanitize(action)
-        param_filter = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
-        payload_sanitized = param_filter.filter(action.payload)
-        action.payload_sanitized = action.payload != payload_sanitized
-        action.payload_unsanitized = action.payload if action.payload_sanitized
-        action.payload = payload_sanitized
-      end
-    end
-  end
-end