axn 0.1.0.pre.alpha.2.5 → 0.1.0.pre.alpha.2.5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad00a162e22de940a1c6e4a4de1f75533fb1aa5440c6cf8808f81a964e2457d4
-  data.tar.gz: dfb840d11657f80f92d3e1aa19bef3cb64b1d28a84f70f0dd1b92c5726f4fd7f
+  metadata.gz: eb044bed464d8840289e69cb631ff47ebc44999ac7e6327fc3b69dd62a37a6af
+  data.tar.gz: 0f0db9209a545ac84b88df56aaeaea431e6094385c433775f8d3f6501d84e870
 SHA512:
-  metadata.gz: 6704196ea530709faf393c51886f0ab4ed34fd5f9654cf4d086d08ba30a455140297bf695d29d0e7a15376b8b3064c9093e882f74f84139e21dc2bdc1e122298
-  data.tar.gz: e319dcdf830b8b49fafa2db5f8461b951bf96db8a57b1b1172075a69db2f1eacd4674807526480d7f56a5fbe03265bf549f755359986a02805a5e982f0c769d1
+  metadata.gz: df227aa350f02e53d8141fec5bd6855ed31c1da64ec9b6567ce3906b86fce2bc6b1b4bc24a38042b565da8c7bee6df0ed95fd0bd1ab5afa8b722397ce10b5f09
+  data.tar.gz: 35b54feff70f62f1b18e9dbe9b0ac066ee6c1b13118f871e9b4bf36a8949661410886b4ac97e019f5c3a89c5f3082c9cebe0008a12c5fc810cbea418ef1c99bc

data/.rubocop.yml

@@ -37,22 +37,22 @@ Metrics/MethodLength:
   Max: 60
 
 Metrics/PerceivedComplexity:
-  Max: 15
+  Max: 16
 
 Metrics/AbcSize:
   Max: 60
 
 Metrics/CyclomaticComplexity:
-  Max: 14
+  Max: 16
 
 Lint/EmptyBlock:
   Enabled: false
 
 Naming/MethodParameterName:
-  AllowedNames: e
+  AllowedNames: e, on, id
 
 Metrics/ParameterLists:
-  Max: 7
+  Max: 9
 
 Layout/LineLength:
   Max: 160

data/CHANGELOG.md

@@ -1,7 +1,11 @@
 # Changelog
 
-## UNRELEASED
-* N/A
+## 0.1.0-alpha.2.5.1.1
+* [BUGFIX] TypeValidator must handle anonymous classes when determining if given argument is an RSpec mock
+
+## 0.1.0-alpha.2.5.1
+* Added new `model` validator for expectations
+* [FEAT] Extended `expects` with the `on:` key to allow declaring nested data shapes/validations
 
 ## 0.1.0-alpha.2.5
 * Support blank exposures for `Action::Result.ok`

data/docs/reference/class.md

@@ -1,3 +1,7 @@
+---
+outline: deep
+---
+
 # Class Methods
 
 ## `.expects` and `.exposes`
@@ -22,7 +26,7 @@ Both `expects` and `exposes` support the same core options:
 While we _support_ complex interface validations, in practice you usually just want a `type`, if anything.  Remember this is your validation about how the action is called, _not_ pretty user-facing errors (there's [a different pattern for that](/recipes/validating-user-input)).
 :::
 
-In addition to the [standard ActiveModel validations](https://guides.rubyonrails.org/active_record_validations.html), we also support two additional custom validators:
+In addition to the [standard ActiveModel validations](https://guides.rubyonrails.org/active_record_validations.html), we also support three additional custom validators:
 * `type: Foo` - fails unless the provided value `.is_a?(Foo)`
   * Edge case: use `type: :boolean` to handle a boolean field (since ruby doesn't have a Boolean class to pass in directly)
   * Edge case: use `type: :uuid` to handle a confirming given string is a UUID (with or without `-` chars)
@@ -31,11 +35,48 @@ In addition to the [standard ActiveModel validations](https://guides.rubyonrails
     ```ruby
     expects :foo, validate: ->(value) { "must be pretty big" unless value > 10 }
     ```
+* `model: true` (or `model: TheModelClass`) - allows auto-hydrating a record when only given its ID
+  * Example:
+    ```ruby
+    expects :user_id, model: true
+    ```
+    This line will add expectations that:
+      * `user_id` is provided
+      * `User.find(user_id)` returns a record
+
+    And, when used on `expects`, will create two reader methods for you:
+      * `user_id` (normal), _and_
+      * `user` (for the auto-found record)
+
+    ::: info NOTES
+    * The field name must end in `_id`
+    * This was designed for ActiveRecord models, but will work on any class that returns an instance from `find_by(id: <the provided ID>)`
+    :::
 
+### Details specific to `.exposes`
+
+Remember that you'll need [a corresponding `expose` call](/reference/instance#expose) for every variable you declare via `exposes`.
 
 
 ### Details specific to `.expects`
 
+#### Nested/Subfield expectations
+
+`expects` is for defining the inbound interface. Usually it's enough to declare the top-level fields you receive, but sometimes you want to make expectations about the shape of that data, and/or to define easy accessor methods for deeply nested fields. `expects` supports the `on` option for this (all the normal attributes can be applied as well, _except default, preprocess, and sensitive_):
+
+```ruby
+class Foo
+  expects :event
+  expects :data, type: Hash, on: :event  # [!code focus:2]
+  expects :some, :random, :fields, on: :data
+
+  def call
+    puts "THe event.data.random field's value is: #{random}"
+  end
+end
+```
+
+#### `preprocess`
 `expects` also supports a `preprocess` option that, if set to a callable, will be executed _before_ applying any validations.  This can be useful for type coercion, e.g.:
 
 ```ruby
@@ -44,11 +85,6 @@ expects :date, type: Date, preprocess: ->(d) { d.is_a?(Date) ? d : Date.parse(d)
 
 will succeed if given _either_ an actual Date object _or_ a string that Date.parse can convert into one.  If the preprocess callable raises an exception, that'll be swallowed and the action failed.
 
-### Details specific to `.exposes`
-
-Remember that you'll need [a corresponding `expose` call](/reference/instance#expose) for every variable you declare via `exposes`.
-
-
 ## `.messages`
 
 The `messages` declaration allows you to customize the `error` and `success` messages on the returned result.

data/lib/action/core/contract.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require "active_model"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/delegation"
 
-require "action/core/contract_validator"
+require "action/core/validation/fields"
 require "action/core/context_facade"
 
 module Action
@@ -34,8 +33,18 @@ module Action
     FieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
 
     module ClassMethods
-      def expects(*fields, allow_blank: false, allow_nil: false, default: nil, preprocess: nil, sensitive: false,
-                  **validations)
+      def expects(
+        *fields,
+        on: nil,
+        allow_blank: false,
+        allow_nil: false,
+        default: nil,
+        preprocess: nil,
+        sensitive: false,
+        **validations
+      )
+        return _expects_subfields(*fields, on:, allow_blank:, allow_nil:, default:, preprocess:, sensitive:, **validations) if on.present?
+
         fields.each do |field|
           raise ContractViolation::ReservedAttributeError, field if RESERVED_FIELD_NAMES_FOR_EXPECTATIONS.include?(field.to_s)
         end
@@ -49,7 +58,14 @@ module Action
         end
       end
 
-      def exposes(*fields, allow_blank: false, allow_nil: false, default: nil, sensitive: false, **validations)
+      def exposes(
+        *fields,
+        allow_blank: false,
+        allow_nil: false,
+        default: nil,
+        sensitive: false,
+        **validations
+      )
         fields.each do |field|
           raise ContractViolation::ReservedAttributeError, field if RESERVED_FIELD_NAMES_FOR_EXPOSURES.include?(field.to_s)
         end
@@ -77,14 +93,44 @@ module Action
         ok error success message
       ].freeze
 
-      def _parse_field_configs(*fields, allow_nil: false, allow_blank: false, default: nil, preprocess: nil, sensitive: false,
-                               **validations)
+      def _parse_field_configs(
+        *fields,
+        allow_blank: false,
+        allow_nil: false,
+        default: nil,
+        preprocess: nil,
+        sensitive: false,
+        **validations
+      )
+        _parse_field_validations(*fields, allow_nil:, allow_blank:, **validations).map do |field, parsed_validations|
+          _define_field_reader(field)
+          _define_model_reader(field, parsed_validations[:model]) if parsed_validations.key?(:model)
+          FieldConfig.new(field:, validations: parsed_validations, default:, preprocess:, sensitive:)
+        end
+      end
+
+      def _define_field_reader(field)
         # Allow local access to explicitly-expected fields -- even externally-expected needs to be available locally
         # (e.g. to allow success message callable to reference exposed fields)
-        fields.each do |field|
-          define_method(field) { internal_context.public_send(field) }
+        define_method(field) { internal_context.public_send(field) }
+      end
+
+      def _define_model_reader(field, klass)
+        name = field.to_s.delete_suffix("_id")
+        raise ArgumentError, "Model validation expects to be given a field ending in _id (given: #{field})" unless field.to_s.end_with?("_id")
+        raise ArgumentError, "Failed to define model reader - #{name} is already defined" if method_defined?(name)
+
+        define_method(name) do
+          Validators::ModelValidator.instance_for(field:, klass:, id: public_send(field))
         end
+      end
 
+      def _parse_field_validations(
+        *fields,
+        allow_nil: false,
+        allow_blank: false,
+        **validations
+      )
         if allow_blank
           validations.transform_values! do |v|
             v = { value: v } unless v.is_a?(Hash)
@@ -99,7 +145,7 @@ module Action
           validations[:presence] = true unless validations.key?(:presence) || Array(validations[:type]).include?(:boolean)
         end
 
-        fields.map { |field| FieldConfig.new(field:, validations:, default:, preprocess:, sensitive:) }
+        fields.map { |field| [field, validations] }
       end
     end
 
@@ -164,7 +210,7 @@ module Action
         context = direction == :inbound ? internal_context : external_context
         exception_klass = direction == :inbound ? Action::InboundValidationError : Action::OutboundValidationError
 
-        ContractValidator.validate!(validations:, context:, exception_klass:)
+        Validation::Fields.validate!(validations:, context:, exception_klass:)
       end
 
       def _apply_defaults!(direction)

data/lib/action/core/contract_for_subfields.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "action/core/validation/subfields"
+
+module Action
+  module ContractForSubfields
+    # TODO: add default, preprocess, sensitive options for subfields?
+    # SubfieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
+    SubfieldConfig = Data.define(:field, :validations, :on)
+
+    def self.included(base)
+      base.class_eval do
+        class_attribute :subfield_configs, default: []
+
+        extend ClassMethods
+        include InstanceMethods
+
+        before { _validate_subfields_contract! }
+      end
+    end
+
+    module ClassMethods
+      def _expects_subfields(
+        *fields,
+        on:,
+        readers: true,
+        allow_blank: false,
+        allow_nil: false,
+
+        # TODO: add support for these three options for subfields
+        default: nil,
+        preprocess: nil,
+        sensitive: false,
+
+        **validations
+      )
+        # TODO: add support for these three options for subfields
+        raise ArgumentError, "expects does not support :default key when also given :on" if default.present?
+        raise ArgumentError, "expects does not support :preprocess key when also given :on" if preprocess.present?
+        raise ArgumentError, "expects does not support :sensitive key when also given :on" if sensitive.present?
+
+        unless internal_field_configs.map(&:field).include?(on) || subfield_configs.map(&:field).include?(on)
+          raise ArgumentError,
+                "expects called with `on: #{on}`, but no such method exists (are you sure you've declared `expects :#{on}`?)"
+        end
+
+        raise ArgumentError, "expects does not support expecting fields on nested attributes (i.e. `on` cannot contain periods)" if on.to_s.include?(".")
+
+        # TODO: consider adding support for default, preprocess, sensitive options for subfields?
+        _parse_subfield_configs(*fields, on:, readers:, allow_blank:, allow_nil:, **validations).tap do |configs|
+          duplicated = subfield_configs.map(&:field) & configs.map(&:field)
+          raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
+
+          # NOTE: avoid <<, which would update value for parents and children
+          self.subfield_configs += configs
+        end
+      end
+
+      private
+
+      def _parse_subfield_configs(
+        *fields,
+        on:,
+        readers:,
+        allow_blank: false,
+        allow_nil: false,
+        # default: nil,
+        # preprocess: nil,
+        # sensitive: false,
+        **validations
+      )
+        _parse_field_validations(*fields, allow_nil:, allow_blank:, **validations).map do |field, parsed_validations|
+          _define_subfield_reader(field, on:, validations: parsed_validations) if readers
+          SubfieldConfig.new(field:, validations: parsed_validations, on:)
+        end
+      end
+
+      def _define_subfield_reader(field, on:, validations:)
+        # Don't create top-level readers for nested fields
+        return if field.to_s.include?(".")
+
+        raise ArgumentError, "expects does not support duplicate sub-keys (i.e. `#{field}` is already defined)" if method_defined?(field)
+
+        define_memoized_reader_method(field) do
+          public_send(on).fetch(field)
+        end
+
+        _define_model_reader(field, validations[:model]) if validations.key?(:model)
+      end
+
+      def define_memoized_reader_method(field, &block)
+        define_method(field) do
+          ivar = :"@_memoized_reader_#{field}"
+          cached_val = instance_variable_get(ivar)
+          return cached_val if cached_val.present?
+
+          value = instance_exec(&block)
+          instance_variable_set(ivar, value)
+        end
+      end
+    end
+
+    module InstanceMethods
+      def _validate_subfields_contract!
+        return if subfield_configs.blank?
+
+        subfield_configs.each do |config|
+          Validation::Subfields.validate!(
+            field: config.field,
+            validations: config.validations,
+            source: public_send(config.on),
+            exception_klass: Action::InboundValidationError,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/action/core/validation/fields.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Action
+  module Validation
+    class Fields
+      include ActiveModel::Validations
+
+      # NOTE: defining classes where needed b/c we explicitly register it'll affect ALL the consuming apps' validators as well
+      ModelValidator = Validators::ModelValidator
+      TypeValidator = Validators::TypeValidator
+      ValidateValidator = Validators::ValidateValidator
+
+      def initialize(context)
+        @context = context
+      end
+
+      def read_attribute_for_validation(attr)
+        @context.public_send(attr)
+      end
+
+      def self.validate!(validations:, context:, exception_klass:)
+        validator = Class.new(self) do
+          def self.name = "Action::Validation::Fields::OneOff"
+
+          validations.each do |field, field_validations|
+            field_validations.each do |key, value|
+              validates field, key => value
+            end
+          end
+        end.new(context)
+
+        return if validator.valid?
+
+        raise exception_klass, validator.errors
+      end
+    end
+  end
+end

data/lib/action/core/validation/subfields.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+
+module Action
+  module Validation
+    class Subfields
+      include ActiveModel::Validations
+
+      # NOTE: defining classes where needed b/c we explicitly register it'll affect ALL the consuming apps' validators as well
+      ModelValidator = Validators::ModelValidator
+      TypeValidator = Validators::TypeValidator
+      ValidateValidator = Validators::ValidateValidator
+
+      def initialize(source)
+        @source = source
+      end
+
+      def read_attribute_for_validation(attr)
+        self.class.extract(attr, @source)
+      end
+
+      def self.extract(attr, source)
+        return source.public_send(attr) if source.respond_to?(attr)
+        raise "Unclear how to extract #{attr} from #{source.inspect}" unless source.respond_to?(:dig)
+
+        base = source.respond_to?(:with_indifferent_access) ? source.with_indifferent_access : source
+        base.dig(*attr.to_s.split("."))
+      end
+
+      def self.validate!(field:, validations:, source:, exception_klass:)
+        validator = Class.new(self) do
+          def self.name = "Action::Validation::Subfields::OneOff"
+
+          validates field, **validations
+        end.new(source)
+
+        return if validator.valid?
+
+        raise exception_klass, validator.errors
+      end
+    end
+  end
+end

data/lib/action/core/validation/validators/model_validator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module Action
+  module Validators
+    class ModelValidator < ActiveModel::EachValidator
+      def self.model_for(field:, klass: nil)
+        return klass if defined?(ActiveRecord::Base) && klass.is_a?(ActiveRecord::Base)
+
+        field.to_s.delete_suffix("_id").classify.constantize
+      end
+
+      def self.instance_for(field:, klass:, id:)
+        klass = model_for(field:, klass:)
+        return unless klass.respond_to?(:find_by)
+
+        klass.find_by(id:)
+      end
+
+      def validate_each(record, attribute, id)
+        klass = self.class.model_for(field: attribute, klass: options[:with])
+        instance = self.class.instance_for(field: attribute, klass:, id:)
+        return if instance.present?
+
+        msg = id.blank? ? "not found (given a blank ID)" : "not found for class #{klass.name} and ID #{id}"
+        record.errors.add(attribute, msg)
+      rescue StandardError => e
+        warn("Model validation on field '#{attribute}' raised #{e.class.name}: #{e.message}")
+
+        record.errors.add(attribute, "error raised while trying to find a valid #{klass.name}")
+      end
+    end
+  end
+end

data/lib/action/core/validation/validators/type_validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module Action
+  module Validators
+    class TypeValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        # NOTE: the last one (:value) might be my fault from the make-it-a-hash fallback in #parse_field_configs
+        types = options[:in].presence || Array(options[:with]).presence || Array(options[:value]).presence
+
+        return if value.blank? && !types.include?(:boolean) # Handled with a separate default presence validator
+
+        msg = types.size == 1 ? "is not a #{types.first}" : "is not one of #{types.join(", ")}"
+        record.errors.add attribute, (options[:message] || msg) unless types.any? do |type|
+          if type == :boolean
+            [true, false].include?(value)
+          elsif type == :uuid
+            value.is_a?(String) && value.match?(/\A[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\z/i)
+          else
+            # NOTE: allow mocks to pass type validation by default (much easier testing ergonomics)
+            next true if Action.config.env.test? && value.class.name&.start_with?("RSpec::Mocks::")
+
+            value.is_a?(type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action/core/validation/validators/validate_validator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module Action
+  module Validators
+    class ValidateValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        msg = begin
+          options[:with].call(value)
+        rescue StandardError => e
+          Action.config.logger.warn("Custom validation on field '#{attribute}' raised #{e.class.name}: #{e.message}")
+
+          "failed validation: #{e.message}"
+        end
+
+        record.errors.add(attribute, msg) if msg.present?
+      end
+    end
+  end
+end

data/lib/axn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Axn
-  VERSION = "0.1.0-alpha.2.5"
+  VERSION = "0.1.0-alpha.2.5.1.1"
 end

data/lib/axn.rb

@@ -6,11 +6,16 @@ require_relative "axn/version"
 require "interactor"
 require "active_support"
 
+require_relative "action/core/validation/validators/model_validator"
+require_relative "action/core/validation/validators/type_validator"
+require_relative "action/core/validation/validators/validate_validator"
+
 require_relative "action/core/exceptions"
 require_relative "action/core/logging"
 require_relative "action/core/configuration"
 require_relative "action/core/top_level_around_hook"
 require_relative "action/core/contract"
+require_relative "action/core/contract_for_subfields"
 require_relative "action/core/swallow_exceptions"
 require_relative "action/core/hoist_errors"
 
@@ -37,8 +42,9 @@ module Action
       # can include those hook executions in any traces set from this hook.
       include TopLevelAroundHook
 
-      include Contract
       include SwallowExceptions
+      include Contract
+      include ContractForSubfields
 
       include HoistErrors
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: axn
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.2.5
+  version: 0.1.0.pre.alpha.2.5.1.1
 platform: ruby
 authors:
 - Kali Donovan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-20 00:00:00.000000000 Z
+date: 2025-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -91,13 +91,18 @@ files:
 - lib/action/core/configuration.rb
 - lib/action/core/context_facade.rb
 - lib/action/core/contract.rb
-- lib/action/core/contract_validator.rb
+- lib/action/core/contract_for_subfields.rb
 - lib/action/core/event_handlers.rb
 - lib/action/core/exceptions.rb
 - lib/action/core/hoist_errors.rb
 - lib/action/core/logging.rb
 - lib/action/core/swallow_exceptions.rb
 - lib/action/core/top_level_around_hook.rb
+- lib/action/core/validation/fields.rb
+- lib/action/core/validation/subfields.rb
+- lib/action/core/validation/validators/model_validator.rb
+- lib/action/core/validation/validators/type_validator.rb
+- lib/action/core/validation/validators/validate_validator.rb
 - lib/action/enqueueable.rb
 - lib/action/enqueueable/enqueue_all_in_background.rb
 - lib/action/enqueueable/enqueue_all_worker.rb

data/lib/action/core/contract_validator.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  class ContractValidator
-    include ActiveModel::Validations
-
-    def initialize(context)
-      @context = context
-    end
-
-    def read_attribute_for_validation(attr)
-      @context.public_send(attr)
-    end
-
-    def self.validate!(validations:, context:, exception_klass:)
-      validator = Class.new(self) do
-        def self.name = "Action::ContractValidator::OneOff"
-
-        validations.each do |field, field_validations|
-          field_validations.each do |key, value|
-            validates field, key => value
-          end
-        end
-      end.new(context)
-
-      return if validator.valid?
-
-      raise exception_klass, validator.errors
-    end
-
-    # Allow for custom validators to be defined in the context of the action
-    class ValidateValidator < ActiveModel::EachValidator
-      def validate_each(record, attribute, value)
-        msg = begin
-          options[:with].call(value)
-        rescue StandardError => e
-          Action.config.logger.warn("Custom validation on field '#{attribute}' raised #{e.class.name}: #{e.message}")
-
-          "failed validation: #{e.message}"
-        end
-
-        record.errors.add(attribute, msg) if msg.present?
-      end
-    end
-
-    class TypeValidator < ActiveModel::EachValidator
-      def validate_each(record, attribute, value)
-        # NOTE: the last one (:value) might be my fault from the make-it-a-hash fallback in #parse_field_configs
-        types = options[:in].presence || Array(options[:with]).presence || Array(options[:value]).presence
-
-        return if value.blank? && !types.include?(:boolean) # Handled with a separate default presence validator
-
-        msg = types.size == 1 ? "is not a #{types.first}" : "is not one of #{types.join(", ")}"
-        record.errors.add attribute, (options[:message] || msg) unless types.any? do |type|
-          if type == :boolean
-            [true, false].include?(value)
-          elsif type == :uuid
-            value.is_a?(String) && value.match?(/\A[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\z/i)
-          else
-            next true if Action.config.env.test? && value.class.name.start_with?("RSpec::Mocks::")
-
-            value.is_a?(type)
-          end
-        end
-      end
-    end
-  end
-end