grape 2.0.0 → 2.1.3

data/lib/grape/dsl/routing.rb

@@ -30,7 +30,7 @@ module Grape
           if args.any?
             options = args.extract_options!
             options = options.reverse_merge(using: :path)
-            requested_versions = args.flatten
+            requested_versions = args.flatten.map(&:to_s)
 
             raise Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
 
@@ -54,7 +54,7 @@ module Grape
 
         # Define a root URL prefix for your entire API.
         def prefix(prefix = nil)
-          namespace_inheritable(:root_prefix, prefix)
+          namespace_inheritable(:root_prefix, prefix&.to_s)
         end
 
         # Create a scope without affecting the URL.
@@ -85,8 +85,8 @@ module Grape
           mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
           mounts.each_pair do |app, path|
             if app.respond_to?(:mount_instance)
-              opts_with = opts.any? ? opts.shift[:with] : {}
-              mount({ app.mount_instance(configuration: opts_with) => path })
+              opts_with = opts.any? ? opts.first[:with] : {}
+              mount({ app.mount_instance(configuration: opts_with) => path }, *opts)
               next
             end
             in_setting = inheritable_setting
@@ -103,6 +103,15 @@ module Grape
               change!
             end
 
+            # When trying to mount multiple times the same endpoint, remove the previous ones
+            # from the list of endpoints if refresh_already_mounted parameter is true
+            refresh_already_mounted = opts.any? ? opts.first[:refresh_already_mounted] : false
+            if refresh_already_mounted && !endpoints.empty?
+              endpoints.delete_if do |endpoint|
+                endpoint.options[:app].to_s == app.to_s
+              end
+            end
+
             endpoints << Grape::Endpoint.new(
               in_setting,
               method: :any,
@@ -225,6 +234,13 @@ module Grape
         def versions
           @versions ||= []
         end
+
+        private
+
+        def refresh_mounted_api(mounts, *opts)
+          opts << { refresh_already_mounted: true }
+          mount(mounts, *opts)
+        end
       end
     end
   end

data/lib/grape/dsl/validations.rb

@@ -38,6 +38,19 @@ module Grape
         def params(&block)
           Grape::Validations::ParamsScope.new(api: self, type: Hash, &block)
         end
+
+        # Declare the contract to be used for the endpoint's parameters.
+        # @param contract [Class<Dry::Validation::Contract> | Dry::Schema::Processor]
+        #   The contract or schema to be used for validation. Optional.
+        # @yield a block yielding a new instance of Dry::Schema::Params
+        #   subclass, allowing to define the schema inline. When the
+        #   +contract+ parameter is a schema, it will be used as a parent. Optional.
+        def contract(contract = nil, &block)
+          raise ArgumentError, 'Either contract or block must be provided' unless contract || block
+          raise ArgumentError, 'Cannot inherit from contract, only schema' if block && contract.respond_to?(:schema)
+
+          Grape::Validations::ContractScope.new(self, contract, &block)
+        end
       end
     end
   end

data/lib/grape/endpoint.rb

@@ -13,8 +13,8 @@ module Grape
     attr_reader :env, :request, :headers, :params
 
     class << self
-      def new(*args, &block)
-        self == Endpoint ? Class.new(Endpoint).new(*args, &block) : super
+      def new(...)
+        self == Endpoint ? Class.new(Endpoint).new(...) : super
       end
 
       def before_each(new_setup = false, &block)
@@ -55,7 +55,7 @@ module Grape
 
         proc do |endpoint_instance|
           ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: endpoint_instance) do
-            method.bind(endpoint_instance).call
+            method.bind_call(endpoint_instance)
           end
         end
       end
@@ -151,7 +151,7 @@ module Grape
         reset_routes!
         routes.each do |route|
           methods = [route.request_method]
-          methods << Grape::Http::Headers::HEAD if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET
+          methods << Rack::HEAD if !namespace_inheritable(:do_not_route_head) && route.request_method == Rack::GET
           methods.each do |method|
             route = Grape::Router::Route.new(method, route.origin, **route.attributes.to_h) unless route.request_method == method
             router.append(route.apply(self))
@@ -190,10 +190,11 @@ module Grape
     end
 
     def prepare_version
-      version = namespace_inheritable(:version) || []
+      version = namespace_inheritable(:version)
+      return unless version
       return if version.empty?
 
-      version.length == 1 ? version.first.to_s : version
+      version.length == 1 ? version.first : version
     end
 
     def merge_route_options(**default)
@@ -206,7 +207,7 @@ module Grape
 
     def prepare_path(path)
       path_settings = inheritable_setting.to_hash[:namespace_stackable].merge(inheritable_setting.to_hash[:namespace_inheritable])
-      Path.prepare(path, namespace, path_settings)
+      Path.new(path, namespace, path_settings)
     end
 
     def namespace
@@ -230,15 +231,15 @@ module Grape
       options[:app].endpoints if options[:app].respond_to?(:endpoints)
     end
 
-    def equals?(e)
-      (options == e.options) && (inheritable_setting.to_hash == e.inheritable_setting.to_hash)
+    def equals?(endpoint)
+      (options == endpoint.options) && (inheritable_setting.to_hash == endpoint.inheritable_setting.to_hash)
     end
 
     protected
 
     def run
       ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
-        @header = {}
+        @header = Grape::Util::Header.new
         @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
         @params = @request.params
         @headers = @request.headers
@@ -401,15 +402,11 @@ module Grape
 
     def options?
       options[:options_route_enabled] &&
-        env[Grape::Http::Headers::REQUEST_METHOD] == Grape::Http::Headers::OPTIONS
+        env[Rack::REQUEST_METHOD] == Rack::OPTIONS
     end
 
-    def method_missing(name, *_args)
-      raise NoMethodError.new("undefined method `#{name}' for #{self.class} in `#{route.origin}' endpoint")
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      super
+    def inspect
+      "#{self.class} in `#{route.origin}' endpoint"
     end
   end
 end

data/lib/grape/{util/env.rb → env.rb}

@@ -11,11 +11,6 @@ module Grape
     API_VENDOR = 'api.vendor'
     API_FORMAT = 'api.format'
 
-    RACK_INPUT = 'rack.input'
-    RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'
-    RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'
-    RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'
-
     GRAPE_REQUEST = 'grape.request'
     GRAPE_REQUEST_HEADERS = 'grape.request.headers'
     GRAPE_REQUEST_PARAMS = 'grape.request.params'

data/lib/grape/error_formatter/txt.rb

@@ -10,16 +10,17 @@ module Grape
           message = present(message, env)
 
           result = message.is_a?(Hash) ? ::Grape::Json.dump(message) : message
-          rescue_options = options[:rescue_options] || {}
-          if rescue_options[:backtrace] && backtrace && !backtrace.empty?
-            result += "\r\n backtrace:"
-            result += backtrace.join("\r\n ")
-          end
-          if rescue_options[:original_exception] && original_exception
-            result += "\r\n original exception:"
-            result += "\r\n #{original_exception.inspect}"
-          end
-          result
+          Array.wrap(result).tap do |final_result|
+            rescue_options = options[:rescue_options] || {}
+            if rescue_options[:backtrace] && backtrace.present?
+              final_result << 'backtrace:'
+              final_result.concat(backtrace)
+            end
+            if rescue_options[:original_exception] && original_exception
+              final_result << 'original exception:'
+              final_result << original_exception.inspect
+            end
+          end.join("\r\n ")
         end
       end
     end

data/lib/grape/exceptions/base.rb

@@ -41,15 +41,15 @@ module Grape
       end
 
       def problem(key, **attributes)
-        translate_message("#{key}.problem".to_sym, **attributes)
+        translate_message(:"#{key}.problem", **attributes)
       end
 
       def summary(key, **attributes)
-        translate_message("#{key}.summary".to_sym, **attributes)
+        translate_message(:"#{key}.summary", **attributes)
       end
 
       def resolution(key, **attributes)
-        translate_message("#{key}.resolution".to_sym, **attributes)
+        translate_message(:"#{key}.resolution", **attributes)
       end
 
       def translate_attributes(keys, **options)

data/lib/grape/exceptions/validation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/exceptions/base'
-
 module Grape
   module Exceptions
     class Validation < Grape::Exceptions::Base

data/lib/grape/exceptions/validation_array_errors.rb

@@ -6,6 +6,7 @@ module Grape
       attr_reader :errors
 
       def initialize(errors)
+        super()
         @errors = errors
       end
     end

data/lib/grape/exceptions/validation_errors.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require 'grape/exceptions/base'
-
 module Grape
   module Exceptions
     class ValidationErrors < Grape::Exceptions::Base
       ERRORS_FORMAT_KEY = 'grape.errors.format'
-      DEFAULT_ERRORS_FORMAT = '%{attributes} %{message}'
+      DEFAULT_ERRORS_FORMAT = '%<attributes>s %<message>s'
 
       include Enumerable
 
@@ -14,7 +12,7 @@ module Grape
 
       def initialize(errors: [], headers: {}, **_options)
         @errors = errors.group_by(&:params)
-        super message: full_messages.join(', '), status: 400, headers: headers
+        super(message: full_messages.join(', '), status: 400, headers: headers)
       end
 
       def each

data/lib/grape/extensions/hash.rb

@@ -12,8 +12,12 @@ module Grape
 
         def build_params
           rack_params.deep_dup.tap do |params|
-            params.deep_merge!(grape_routing_args) if env.key?(Grape::Env::GRAPE_ROUTING_ARGS)
             params.deep_symbolize_keys!
+
+            if env.key?(Grape::Env::GRAPE_ROUTING_ARGS)
+              grape_routing_args.deep_symbolize_keys!
+              params.deep_merge!(grape_routing_args)
+            end
           end
         end
       end

data/lib/grape/http/headers.rb

@@ -1,46 +1,30 @@
 # frozen_string_literal: true
 
-require 'grape/util/lazy_object'
-
 module Grape
   module Http
     module Headers
-      # https://github.com/rack/rack/blob/master/lib/rack.rb
-      HTTP_VERSION    = 'HTTP_VERSION'
-      PATH_INFO       = 'PATH_INFO'
-      REQUEST_METHOD  = 'REQUEST_METHOD'
-      QUERY_STRING    = 'QUERY_STRING'
-
-      if Grape.lowercase_headers?
-        ALLOW             = 'allow'
-        LOCATION          = 'location'
-        TRANSFER_ENCODING = 'transfer-encoding'
-        X_CASCADE         = 'x-cascade'
-      else
-        ALLOW             = 'Allow'
-        LOCATION          = 'Location'
-        TRANSFER_ENCODING = 'Transfer-Encoding'
-        X_CASCADE         = 'X-Cascade'
-      end
-
-      GET     = 'GET'
-      POST    = 'POST'
-      PUT     = 'PUT'
-      PATCH   = 'PATCH'
-      DELETE  = 'DELETE'
-      HEAD    = 'HEAD'
-      OPTIONS = 'OPTIONS'
+      HTTP_ACCEPT_VERSION = 'HTTP_ACCEPT_VERSION'
+      HTTP_ACCEPT = 'HTTP_ACCEPT'
+      HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'
 
-      SUPPORTED_METHODS = [GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS].freeze
-      SUPPORTED_METHODS_WITHOUT_OPTIONS = Grape::Util::LazyObject.new { [GET, POST, PUT, PATCH, DELETE, HEAD].freeze }
+      ALLOW = 'Allow'
+      LOCATION = 'Location'
+      X_CASCADE = 'X-Cascade'
+      TRANSFER_ENCODING = 'Transfer-Encoding'
 
-      HTTP_ACCEPT_VERSION    = 'HTTP_ACCEPT_VERSION'
-      HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'
-      HTTP_ACCEPT            = 'HTTP_ACCEPT'
+      SUPPORTED_METHODS = [
+        Rack::GET,
+        Rack::POST,
+        Rack::PUT,
+        Rack::PATCH,
+        Rack::DELETE,
+        Rack::HEAD,
+        Rack::OPTIONS
+      ].freeze
 
-      FORMAT                 = 'format'
+      SUPPORTED_METHODS_WITHOUT_OPTIONS = (SUPPORTED_METHODS - [Rack::OPTIONS]).freeze
 
-      HTTP_HEADERS = Grape::Util::LazyObject.new do
+      HTTP_HEADERS = Grape::Util::Lazy::Object.new do
         common_http_headers = %w[
           Version
           Host

data/lib/grape/{util/json.rb → json.rb}

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Grape
-  if Object.const_defined? :MultiJson
+  if defined?(::MultiJson)
     Json = ::MultiJson
   else
     Json = ::JSON

data/lib/grape/locale/en.yml

@@ -10,6 +10,9 @@ en:
         values: 'does not have a valid value'
         except_values: 'has a value not allowed'
         same_as: 'is not the same as %{parameter}'
+        length: 'is expected to have length within %{min} and %{max}'
+        length_min: 'is expected to have length greater than or equal to %{min}'
+        length_max: 'is expected to have length less than or equal to %{max}'
         missing_vendor_option:
           problem: 'missing :vendor option'
           summary: 'when version using header, you must specify :vendor option'

data/lib/grape/middleware/auth/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'rack/auth/basic'
-
 module Grape
   module Middleware
     module Auth

data/lib/grape/middleware/auth/dsl.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'rack/auth/basic'
-
 module Grape
   module Middleware
     module Auth

data/lib/grape/middleware/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/dsl/headers'
-
 module Grape
   module Middleware
     class Base
@@ -76,7 +74,7 @@ module Grape
       end
 
       def mime_types
-        @mime_type ||= content_types.each_pair.with_object({}) do |(k, v), types_without_params|
+        @mime_types ||= content_types.each_pair.with_object({}) do |(k, v), types_without_params|
           types_without_params[v.split(';').first] = k
         end
       end

data/lib/grape/middleware/error.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-require 'active_support/core_ext/string/output_safety'
-
 module Grape
   module Middleware
     class Error < Base
@@ -34,66 +31,59 @@ module Grape
 
       def call!(env)
         @env = env
-        begin
-          error_response(catch(:error) do
-            return @app.call(@env)
-          end)
-        rescue Exception => e # rubocop:disable Lint/RescueException
-          handler =
-            rescue_handler_for_base_only_class(e.class) ||
-            rescue_handler_for_class_or_its_ancestor(e.class) ||
-            rescue_handler_for_grape_exception(e.class) ||
-            rescue_handler_for_any_class(e.class) ||
-            raise
-
-          run_rescue_handler(handler, e)
-        end
-      end
-
-      def error!(message, status = options[:default_status], headers = {}, backtrace = [], original_exception = nil)
-        headers = headers.reverse_merge(Rack::CONTENT_TYPE => content_type)
-        rack_response(format_message(message, backtrace, original_exception), status, headers)
+        error_response(catch(:error) { return @app.call(@env) })
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        run_rescue_handler(find_handler(e.class), e, @env[Grape::Env::API_ENDPOINT])
       end
 
-      def default_rescue_handler(e)
-        error_response(message: e.message, backtrace: e.backtrace, original_exception: e)
-      end
-
-      # TODO: This method is deprecated. Refactor out.
-      def error_response(error = {})
-        status = error[:status] || options[:default_status]
-        message = error[:message] || options[:default_message]
-        headers = { Rack::CONTENT_TYPE => content_type }
-        headers.merge!(error[:headers]) if error[:headers].is_a?(Hash)
-        backtrace = error[:backtrace] || error[:original_exception]&.backtrace || []
-        original_exception = error.is_a?(Exception) ? error : error[:original_exception] || nil
-        rack_response(format_message(message, backtrace, original_exception), status, headers)
-      end
+      private
 
-      def rack_response(message, status = options[:default_status], headers = { Rack::CONTENT_TYPE => content_type })
-        message = ERB::Util.html_escape(message) if headers[Rack::CONTENT_TYPE] == TEXT_HTML
-        Rack::Response.new([message], Rack::Utils.status_code(status), headers)
+      def rack_response(status, headers, message)
+        message = Rack::Utils.escape_html(message) if headers[Rack::CONTENT_TYPE] == TEXT_HTML
+        Rack::Response.new(Array.wrap(message), Rack::Utils.status_code(status), Grape::Util::Header.new.merge(headers))
       end
 
       def format_message(message, backtrace, original_exception = nil)
         format = env[Grape::Env::API_FORMAT] || options[:format]
         formatter = Grape::ErrorFormatter.formatter_for(format, **options)
+        return formatter.call(message, backtrace, options, env, original_exception) if formatter
+
         throw :error,
               status: 406,
               message: "The requested format '#{format}' is not supported.",
               backtrace: backtrace,
-              original_exception: original_exception unless formatter
-        formatter.call(message, backtrace, options, env, original_exception)
+              original_exception: original_exception
       end
 
-      private
+      def find_handler(klass)
+        rescue_handler_for_base_only_class(klass) ||
+          rescue_handler_for_class_or_its_ancestor(klass) ||
+          rescue_handler_for_grape_exception(klass) ||
+          rescue_handler_for_any_class(klass) ||
+          raise
+      end
+
+      def error_response(error = {})
+        status = error[:status] || options[:default_status]
+        message = error[:message] || options[:default_message]
+        headers = { Rack::CONTENT_TYPE => content_type }.tap do |h|
+          h.merge!(error[:headers]) if error[:headers].is_a?(Hash)
+        end
+        backtrace = error[:backtrace] || error[:original_exception]&.backtrace || []
+        original_exception = error.is_a?(Exception) ? error : error[:original_exception] || nil
+        rack_response(status, headers, format_message(message, backtrace, original_exception))
+      end
+
+      def default_rescue_handler(exception)
+        error_response(message: exception.message, backtrace: exception.backtrace, original_exception: exception)
+      end
 
       def rescue_handler_for_base_only_class(klass)
         error, handler = options[:base_only_rescue_handlers].find { |err, _handler| klass == err }
 
         return unless error
 
-        handler || :default_rescue_handler
+        handler || method(:default_rescue_handler)
       end
 
       def rescue_handler_for_class_or_its_ancestor(klass)
@@ -101,39 +91,54 @@ module Grape
 
         return unless error
 
-        handler || :default_rescue_handler
+        handler || method(:default_rescue_handler)
       end
 
       def rescue_handler_for_grape_exception(klass)
         return unless klass <= Grape::Exceptions::Base
-        return :error_response if klass == Grape::Exceptions::InvalidVersionHeader
+        return method(:error_response) if klass == Grape::Exceptions::InvalidVersionHeader
         return unless options[:rescue_grape_exceptions] || !options[:rescue_all]
 
-        options[:grape_exceptions_rescue_handler] || :error_response
+        options[:grape_exceptions_rescue_handler] || method(:error_response)
       end
 
       def rescue_handler_for_any_class(klass)
         return unless klass <= StandardError
         return unless options[:rescue_all] || options[:rescue_grape_exceptions]
 
-        options[:all_rescue_handler] || :default_rescue_handler
+        options[:all_rescue_handler] || method(:default_rescue_handler)
       end
 
-      def run_rescue_handler(handler, error)
+      def run_rescue_handler(handler, error, endpoint)
         if handler.instance_of?(Symbol)
           raise NoMethodError, "undefined method '#{handler}'" unless respond_to?(handler)
 
           handler = public_method(handler)
         end
 
-        response = handler.arity.zero? ? instance_exec(&handler) : instance_exec(error, &handler)
+        response = catch(:error) do
+          handler.arity.zero? ? endpoint.instance_exec(&handler) : endpoint.instance_exec(error, &handler)
+        end
+
+        response = error!(response[:message], response[:status], response[:headers]) if error?(response)
 
         if response.is_a?(Rack::Response)
           response
         else
-          run_rescue_handler(:default_rescue_handler, Grape::Exceptions::InvalidResponse.new)
+          run_rescue_handler(:default_rescue_handler, Grape::Exceptions::InvalidResponse.new, endpoint)
         end
       end
+
+      def error!(message, status = options[:default_status], headers = {}, backtrace = [], original_exception = nil)
+        rack_response(
+          status, headers.reverse_merge(Rack::CONTENT_TYPE => content_type),
+          format_message(message, backtrace, original_exception)
+        )
+      end
+
+      def error?(response)
+        response.is_a?(Hash) && response[:message] && response[:status] && response[:headers]
+      end
     end
   end
 end

data/lib/grape/middleware/formatter.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     class Formatter < Base
       CHUNKED = 'chunked'
+      FORMAT = 'format'
 
       def default_options
         {
@@ -26,7 +25,7 @@ module Grape
         status, headers, bodies = *@app_response
 
         if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
-          @app_response
+          [status, headers, []]
         else
           build_formatted_response(status, headers, bodies)
         end
@@ -82,14 +81,14 @@ module Grape
           !request.parseable_data? &&
           (request.content_length.to_i.positive? || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
 
-        return unless (input = env[Grape::Env::RACK_INPUT])
+        return unless (input = env[Rack::RACK_INPUT])
 
-        input.rewind
+        rewind_input input
         body = env[Grape::Env::API_REQUEST_INPUT] = input.read
         begin
           read_rack_input(body) if body && !body.empty?
         ensure
-          input.rewind
+          rewind_input input
         end
       end
 
@@ -103,12 +102,12 @@ module Grape
           begin
             body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
             if body.is_a?(Hash)
-              env[Grape::Env::RACK_REQUEST_FORM_HASH] = if env.key?(Grape::Env::RACK_REQUEST_FORM_HASH)
-                                                          env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)
-                                                        else
-                                                          body
-                                                        end
-              env[Grape::Env::RACK_REQUEST_FORM_INPUT] = env[Grape::Env::RACK_INPUT]
+              env[Rack::RACK_REQUEST_FORM_HASH] = if env.key?(Rack::RACK_REQUEST_FORM_HASH)
+                                                    env[Rack::RACK_REQUEST_FORM_HASH].merge(body)
+                                                  else
+                                                    body
+                                                  end
+              env[Rack::RACK_REQUEST_FORM_INPUT] = env[Rack::RACK_INPUT]
             end
           rescue Grape::Exceptions::Base => e
             raise e
@@ -141,7 +140,7 @@ module Grape
       end
 
       def format_from_params
-        fmt = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[Grape::Http::Headers::FORMAT]
+        fmt = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[FORMAT]
         # avoid symbol memory leak on an unknown format
         return fmt.to_sym if content_type_for(fmt)
 
@@ -174,6 +173,10 @@ module Grape
               .sort_by { |_, quality_preference| -(quality_preference ? quality_preference.to_f : 1.0) }
               .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] }
       end
+
+      def rewind_input(input)
+        input.rewind if input.respond_to?(:rewind)
+      end
     end
   end
 end