rubocop 0.85.1 → 0.89.0

data/lib/rubocop/config_loader.rb

@@ -18,25 +18,23 @@ module RuboCop
     XDG_CONFIG = 'config.yml'
     RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
     DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
-    AUTO_GENERATED_FILE = '.rubocop_todo.yml'
 
     class << self
       include FileFinder
 
-      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion,
-                    :options_config, :disable_pending_cops, :enable_pending_cops
-      attr_writer :default_configuration
+      attr_accessor :debug, :ignore_parent_exclusion,
+                    :disable_pending_cops, :enable_pending_cops
+      attr_writer :default_configuration, :project_root
 
       alias debug? debug
-      alias auto_gen_config? auto_gen_config
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
       def clear_options
-        @debug = @auto_gen_config = @options_config = nil
+        @debug = nil
         FileFinder.root_level = nil
       end
 
-      def load_file(file) # rubocop:disable Metrics/AbcSize
+      def load_file(file)
         path = File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
 
         hash = load_yaml_configuration(path)
@@ -55,6 +53,21 @@ module RuboCop
         Config.create(hash, path)
       end
 
+      def load_yaml_configuration(absolute_path)
+        file_contents = read_file(absolute_path)
+        yaml_code = Dir.chdir(File.dirname(absolute_path)) do
+          ERB.new(file_contents).result
+        end
+        check_duplication(yaml_code, absolute_path)
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
+
+        puts "configuration from #{absolute_path}" if debug?
+
+        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
+
+        hash
+      end
+
       def add_missing_namespaces(path, hash)
         # Using `hash.each_key` will cause the
         # `can't add a new key into hash during iteration` error
@@ -85,7 +98,7 @@ module RuboCop
       end
 
       def configuration_from_file(config_file)
-        return ConfigLoader.default_configuration if config_file == DEFAULT_FILE
+        return default_configuration if config_file == DEFAULT_FILE
 
         config = load_file(config_file)
         if ignore_parent_exclusion?
@@ -105,15 +118,13 @@ module RuboCop
       end
 
       def add_excludes_from_files(config, config_file)
-        found_files = find_files_upwards(DOTFILE, config_file) +
-                      [find_user_dotfile, find_user_xdg_config].compact
+        exclusion_file = find_last_file_upwards(DOTFILE, config_file, project_root)
 
-        return if found_files.empty?
-        return if PathUtil.relative_path(found_files.last) ==
-                  PathUtil.relative_path(config_file)
+        return unless exclusion_file
+        return if PathUtil.relative_path(exclusion_file) == PathUtil.relative_path(config_file)
 
         print 'AllCops/Exclude ' if debug?
-        config.add_excludes_from_higher_level(load_file(found_files.last))
+        config.add_excludes_from_higher_level(load_file(exclusion_file))
       end
 
       def default_configuration
@@ -123,6 +134,12 @@ module RuboCop
                                    end
       end
 
+      # Returns the path rubocop inferred as the root of the project. No file
+      # searches will go past this directory.
+      def project_root
+        @project_root ||= find_project_root
+      end
+
       def warn_on_pending_cops(pending_cops)
         return if pending_cops.empty?
 
@@ -139,40 +156,23 @@ module RuboCop
         warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
       end
 
-      # Merges the given configuration with the default one. If
-      # AllCops:DisabledByDefault is true, it changes the Enabled params so
-      # that only cops from user configuration are enabled.
-      # If AllCops::EnabledByDefault is true, it changes the Enabled params
-      # so that only cops explicitly disabled in user configuration are
-      # disabled.
+      # Merges the given configuration with the default one.
       def merge_with_default(config, config_file, unset_nil: true)
         resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
       end
 
-      def add_inheritance_from_auto_generated_file
-        file_string = " #{AUTO_GENERATED_FILE}"
-
-        config_file = options_config || DOTFILE
-
-        if File.exist?(config_file)
-          files = Array(load_yaml_configuration(config_file)['inherit_from'])
-
-          return if files.include?(AUTO_GENERATED_FILE)
-
-          files.unshift(AUTO_GENERATED_FILE)
-          file_string = "\n  - " + files.join("\n  - ") if files.size > 1
-          rubocop_yml_contents = existing_configuration(config_file)
-        end
-
-        write_config_file(config_file, file_string, rubocop_yml_contents)
+      private
 
-        puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{DOTFILE}`."
+      def find_project_dotfile(target_dir)
+        find_file_upwards(DOTFILE, target_dir, project_root)
       end
 
-      private
+      def find_project_root
+        pwd = Dir.pwd
+        gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
+        return unless gems_file
 
-      def find_project_dotfile(target_dir)
-        find_file_upwards(DOTFILE, target_dir)
+        File.dirname(gems_file)
       end
 
       def find_user_dotfile
@@ -196,38 +196,10 @@ module RuboCop
         path
       end
 
-      def existing_configuration(config_file)
-        IO.read(config_file, encoding: Encoding::UTF_8)
-          .sub(/^inherit_from: *[^\n]+/, '')
-          .sub(/^inherit_from: *(\n *- *[^\n]+)+/, '')
-      end
-
-      def write_config_file(file_name, file_string, rubocop_yml_contents)
-        File.open(file_name, 'w') do |f|
-          f.write "inherit_from:#{file_string}\n"
-          f.write "\n#{rubocop_yml_contents}" if /\S/.match?(rubocop_yml_contents)
-        end
-      end
-
       def resolver
         @resolver ||= ConfigLoaderResolver.new
       end
 
-      def load_yaml_configuration(absolute_path)
-        file_contents = read_file(absolute_path)
-        yaml_code = Dir.chdir(File.dirname(absolute_path)) do
-          ERB.new(file_contents).result
-        end
-        check_duplication(yaml_code, absolute_path)
-        hash = yaml_safe_load(yaml_code, absolute_path) || {}
-
-        puts "configuration from #{absolute_path}" if debug?
-
-        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
-
-        hash
-      end
-
       def check_duplication(yaml_code, absolute_path)
         smart_path = PathUtil.smart_path(absolute_path)
         YAMLDuplicationChecker.check(yaml_code, absolute_path) do |key1, key2|

data/lib/rubocop/config_loader_resolver.rb

@@ -192,7 +192,7 @@ module RuboCop
 
     def remote_file?(uri)
       regex = URI::DEFAULT_PARSER.make_regexp(%w[http https])
-      uri =~ /\A#{regex}\z/
+      /\A#{regex}\z/.match?(uri)
     end
 
     def handle_disabled_by_default(config, new_default_configuration)
@@ -201,7 +201,7 @@ module RuboCop
         next unless dept_params['Enabled']
 
         new_default_configuration.each do |cop, params|
-          next unless cop.start_with?(dept + '/')
+          next unless cop.start_with?("#{dept}/")
 
           # Retain original default configuration for cops in the department.
           params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
@@ -213,8 +213,8 @@ module RuboCop
       end
     end
 
-    def transform(config)
-      config.transform_values { |params| yield(params) }
+    def transform(config, &block)
+      config.transform_values(&block)
     end
 
     def gem_config_path(gem_name, relative_config_path)

data/lib/rubocop/config_obsoletion.rb

@@ -63,7 +63,6 @@ module RuboCop
       'Layout/SpaceAfterControlKeyword' => 'Layout/SpaceAroundKeyword',
       'Layout/SpaceBeforeModifierKeyword' => 'Layout/SpaceAroundKeyword',
       'Lint/RescueWithoutErrorClass' => 'Style/RescueStandardError',
-      'Rails/DefaultScope' => nil,
       'Style/SpaceAfterControlKeyword' => 'Layout/SpaceAroundKeyword',
       'Style/SpaceBeforeModifierKeyword' => 'Layout/SpaceAroundKeyword',
       'Style/TrailingComma' => 'Style/TrailingCommaInArguments, ' \
@@ -85,7 +84,12 @@ module RuboCop
       'Lint/InvalidCharacterLiteral' => 'it was never being actually triggered',
       'Lint/SpaceBeforeFirstArg' =>
         'it was a duplicate of `Layout/SpaceBeforeFirstArg`. Please use ' \
-        '`Layout/SpaceBeforeFirstArg` instead'
+        '`Layout/SpaceBeforeFirstArg` instead',
+      'Style/MethodMissingSuper' => 'it has been superseded by `Lint/MissingSuper`. Please use ' \
+        '`Lint/MissingSuper` instead',
+      'Lint/UselessComparison' => 'it has been superseded by '\
+        '`Lint/BinaryOperatorWithIdenticalOperands`. Please use '\
+        '`Lint/BinaryOperatorWithIdenticalOperands` instead'
     }.map do |cop_name, reason|
       [cop_name, "The `#{cop_name}` cop has been removed since #{reason}."]
     end

data/lib/rubocop/config_store.rb

@@ -33,6 +33,10 @@ module RuboCop
       for_dir(File.dirname(file))
     end
 
+    def for_pwd
+      for_dir(Dir.pwd)
+    end
+
     # If type (file/dir) is known beforehand,
     # prefer using #for_file or #for_dir for improved performance
     def for(file_or_dir)

data/lib/rubocop/config_validator.rb

@@ -23,7 +23,6 @@ module RuboCop
       @target_ruby = TargetRuby.new(config)
     end
 
-    # rubocop:disable Metrics/AbcSize
     def validate
       check_cop_config_value(@config)
       reject_conflicting_safe_settings
@@ -45,7 +44,6 @@ module RuboCop
       validate_syntax_cop
       reject_mutually_exclusive_defaults
     end
-    # rubocop:enable Metrics/AbcSize
 
     def target_ruby_version
       target_ruby.version
@@ -150,7 +148,7 @@ module RuboCop
       end
     end
 
-    def validate_enforced_styles(valid_cop_names)
+    def validate_enforced_styles(valid_cop_names) # rubocop:todo Metrics/AbcSize
       valid_cop_names.each do |name|
         styles = @config[name].select { |key, _| key.start_with?('Enforced') }
 

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -13,11 +13,7 @@ module RuboCop
       end
 
       def correctable?
-        support_autocorrect? || disable_uncorrectable?
-      end
-
-      def support_autocorrect?
-        respond_to?(:autocorrect)
+        self.class.support_autocorrect? || disable_uncorrectable?
       end
 
       def disable_uncorrectable?
@@ -40,8 +36,9 @@ module RuboCop
         true
       end
 
-      def disable_offense(node)
-        range = node.location.expression
+      private
+
+      def disable_offense(range)
         eol_comment = " # rubocop:todo #{cop_name}"
         needed_line_length = (range.source_line + eol_comment).length
         if needed_line_length <= max_line_length
@@ -52,8 +49,6 @@ module RuboCop
         end
       end
 
-      private
-
       def range_of_first_line(range)
         begin_of_first_line = range.begin_pos - range.column
         end_of_first_line = begin_of_first_line + range.source_line.length
@@ -78,27 +73,22 @@ module RuboCop
       end
 
       def max_line_length
-        config.for_cop('Layout/LineLength')['Max'] || 80
+        config.for_cop('Layout/LineLength')['Max'] || 120
       end
 
       def disable_offense_at_end_of_line(range, eol_comment)
-        ->(corrector) { corrector.insert_after(range, eol_comment) }
+        Corrector.new(range).insert_after(range, eol_comment)
       end
 
       def disable_offense_before_and_after(range_by_lines)
-        lambda do |corrector|
-          range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
-          leading_whitespace = range_by_lines.source_line[/^\s*/]
-
-          corrector.insert_before(
-            range_with_newline,
-            "#{leading_whitespace}# rubocop:todo #{cop_name}\n"
-          )
-          corrector.insert_after(
-            range_with_newline,
-            "#{leading_whitespace}# rubocop:enable #{cop_name}\n"
-          )
-        end
+        range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
+        leading_whitespace = range_by_lines.source_line[/^\s*/]
+
+        Corrector.new(range_by_lines).wrap(
+          range_with_newline,
+          "#{leading_whitespace}# rubocop:todo #{cop_name}\n",
+          "#{leading_whitespace}# rubocop:enable #{cop_name}\n"
+        )
       end
     end
   end

data/lib/rubocop/cop/badge.rb

@@ -58,7 +58,7 @@ module RuboCop
       end
 
       def to_s
-        qualified? ? "#{department}/#{cop_name}" : cop_name
+        @to_s ||= qualified? ? "#{department}/#{cop_name}" : cop_name
       end
 
       def qualified?

data/lib/rubocop/cop/base.rb

@@ -0,0 +1,407 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A scaffold for concrete cops.
+    #
+    # The Cop::Base class is meant to be extended.
+    #
+    # Cops track offenses and can autocorrect them on the fly.
+    #
+    # A commissioner object is responsible for traversing the AST and invoking
+    # the specific callbacks on each cop.
+    #
+    # First the callback `on_new_investigation` is called;
+    # if a cop needs to do its own processing of the AST or depends on
+    # something else.
+    #
+    # Then callbacks like `on_def`, `on_send` (see AST::Traversal) are called
+    # with their respective nodes.
+    #
+    # Finally the callback `on_investigation_end` is called.
+    #
+    # Within these callbacks, cops are meant to call `add_offense` or
+    # `add_global_offense`. Use the `processed_source` method to
+    # get the currently processed source being investigated.
+    #
+    # In case of invalid syntax / unparseable content,
+    # the callback `on_other_file` is called instead of all the other
+    # `on_...` callbacks.
+    #
+    # Private methods are not meant for custom cops consumption,
+    # nor are any instance variables.
+    #
+    class Base # rubocop:disable Metrics/ClassLength
+      extend RuboCop::AST::Sexp
+      extend NodePattern::Macros
+      include RuboCop::AST::Sexp
+      include Util
+      include IgnoredNode
+      include AutocorrectLogic
+
+      attr_reader :config, :processed_source
+
+      # Reports of an investigation.
+      # Immutable
+      # Consider creation API private
+      InvestigationReport = Struct.new(:cop, :processed_source, :offenses, :corrector)
+
+      # List of cops that should not try to autocorrect at the same
+      # time as this cop
+      #
+      # @return [Array<RuboCop::Cop::Cop>]
+      #
+      # @api public
+      def self.autocorrect_incompatible_with
+        []
+      end
+
+      def initialize(config = nil, options = nil)
+        @config = config || Config.new
+        @options = options || { debug: false }
+        reset_investigation
+      end
+
+      # Called before all on_... have been called
+      # When refining this method, always call `super`
+      def on_new_investigation
+        # Typically do nothing here
+      end
+
+      # Called after all on_... have been called
+      # When refining this method, always call `super`
+      def on_investigation_end
+        # Typically do nothing here
+      end
+
+      # Called instead of all on_... callbacks for unrecognized files / syntax errors
+      # When refining this method, always call `super`
+      def on_other_file
+        # Typically do nothing here
+      end
+
+      # Override and return the Force class(es) you need to join
+      def self.joining_forces; end
+
+      # Gets called if no message is specified when calling `add_offense` or
+      # `add_global_offense`
+      # Cops are discouraged to override this; instead pass your message directly
+      def message(_range = nil)
+        self.class::MSG
+      end
+
+      # Adds an offense that has no particular location.
+      # No correction can be applied to global offenses
+      def add_global_offense(message = nil, severity: nil)
+        severity = find_severity(nil, severity)
+        message = find_message(nil, message)
+        @current_offenses <<
+          Offense.new(severity, Offense::NO_LOCATION, message, name, :unsupported)
+      end
+
+      # Adds an offense on the specified range (or node with an expression)
+      # Unless that offense is disabled for this range, a corrector will be yielded
+      # to provide the cop the opportunity to autocorrect the offense.
+      # If message is not specified, the method `message` will be called.
+      def add_offense(node_or_range, message: nil, severity: nil, &block)
+        range = range_from_node_or_range(node_or_range)
+        return unless current_offense_locations.add?(range)
+
+        range_to_pass = callback_argument(range)
+
+        severity = find_severity(range_to_pass, severity)
+        message = find_message(range_to_pass, message)
+
+        status, corrector = enabled_line?(range.line) ? correct(range, &block) : :disabled
+
+        @current_offenses << Offense.new(severity, range, message, name, status, corrector)
+      end
+
+      # This method should be overridden when a cop's behavior depends
+      # on state that lives outside of these locations:
+      #
+      #   (1) the file under inspection
+      #   (2) the cop's source code
+      #   (3) the config (eg a .rubocop.yml file)
+      #
+      # For example, some cops may want to look at other parts of
+      # the codebase being inspected to find violations. A cop may
+      # use the presence or absence of file `foo.rb` to determine
+      # whether a certain violation exists in `bar.rb`.
+      #
+      # Overriding this method allows the cop to indicate to RuboCop's
+      # ResultCache system when those external dependencies change,
+      # ie when the ResultCache should be invalidated.
+      def external_dependency_checksum
+        nil
+      end
+
+      def self.inherited(subclass)
+        super
+        Registry.global.enlist(subclass)
+      end
+
+      # Call for abstract Cop classes
+      def self.exclude_from_registry
+        Registry.global.dismiss(self)
+      end
+
+      # Returns if class supports auto_correct.
+      # It is recommended to extend AutoCorrector instead of overriding
+      def self.support_autocorrect?
+        false
+      end
+
+      ### Naming
+
+      def self.badge
+        @badge ||= Badge.for(name)
+      end
+
+      def self.cop_name
+        badge.to_s
+      end
+
+      def self.department
+        badge.department
+      end
+
+      def self.lint?
+        department == :Lint
+      end
+
+      # Returns true if the cop name or the cop namespace matches any of the
+      # given names.
+      def self.match?(given_names)
+        return false unless given_names
+
+        given_names.include?(cop_name) ||
+          given_names.include?(department.to_s)
+      end
+
+      def cop_name
+        @cop_name ||= self.class.cop_name
+      end
+
+      alias name cop_name
+
+      ### Configuration Helpers
+
+      def cop_config
+        # Use department configuration as basis, but let individual cop
+        # configuration override.
+        @cop_config ||= @config.for_badge(self.class.badge)
+      end
+
+      def config_to_allow_offenses
+        Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses[cop_name] ||= {}
+      end
+
+      def config_to_allow_offenses=(hash)
+        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] =
+          hash
+      end
+
+      def target_ruby_version
+        @config.target_ruby_version
+      end
+
+      def target_rails_version
+        @config.target_rails_version
+      end
+
+      def relevant_file?(file)
+        file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
+          file_name_matches_any?(file, 'Include', true) &&
+            !file_name_matches_any?(file, 'Exclude', false)
+      end
+
+      def excluded_file?(file)
+        !relevant_file?(file)
+      end
+
+      ### Persistence
+
+      # Override if your cop should be called repeatedly for multiple investigations
+      # Between calls to `on_new_investigation` and `on_investigation_end`,
+      # the result of `processed_source` will remain constant.
+      # You should invalidate any caches that depend on the current `processed_source`
+      # in the `on_new_investigation` callback.
+      # If your cop does autocorrections, be aware that your instance may be called
+      # multiple times with the same `processed_source.path` but different content.
+      def self.support_multiple_source?
+        false
+      end
+
+      # @api private
+      # Called between investigations
+      def ready
+        return self if self.class.support_multiple_source?
+
+        self.class.new(@config, @options)
+      end
+
+      ### Reserved for Cop::Cop
+
+      # @deprecated Make potential errors with previous API more obvious
+      def offenses
+        raise 'The offenses are not directly available; ' \
+          'they are returned as the result of the investigation'
+      end
+
+      private
+
+      ### Reserved for Cop::Cop
+
+      def callback_argument(range)
+        range
+      end
+
+      def apply_correction(corrector)
+        @current_corrector&.merge!(corrector) if corrector
+      end
+
+      def correction_strategy
+        return :unsupported unless correctable?
+        return :uncorrected unless autocorrect?
+
+        :attempt_correction
+      end
+
+      ### Reserved for Commissioner:
+
+      def current_offense_locations
+        @current_offense_locations ||= Set.new
+      end
+
+      def currently_disabled_lines
+        @currently_disabled_lines ||= Set.new
+      end
+
+      # Called before any investigation
+      def begin_investigation(processed_source)
+        @current_offenses = []
+        @current_offense_locations = nil
+        @currently_disabled_lines = nil
+        @processed_source = processed_source
+        @current_corrector = Corrector.new(@processed_source) if @processed_source.valid_syntax?
+      end
+
+      # Called to complete an investigation
+      def complete_investigation
+        InvestigationReport.new(self, processed_source, @current_offenses, @current_corrector)
+      ensure
+        reset_investigation
+      end
+
+      ### Actually private methods
+
+      def reset_investigation
+        @currently_disabled_lines = @current_offenses = @processed_source = @current_corrector = nil
+      end
+
+      # @return [Symbol, Corrector] offense status
+      def correct(range)
+        status = correction_strategy
+
+        if block_given?
+          corrector = Corrector.new(self)
+          yield corrector
+          if !corrector.empty? && !self.class.support_autocorrect?
+            raise "The Cop #{name} must `extend AutoCorrector` to be able to autocorrect"
+          end
+        end
+
+        status = attempt_correction(range, corrector) if status == :attempt_correction
+
+        [status, corrector]
+      end
+
+      # @return [Symbol] offense status
+      def attempt_correction(range, corrector)
+        if corrector && !corrector.empty?
+          status = :corrected
+        elsif disable_uncorrectable?
+          corrector = disable_uncorrectable(range)
+          status = :corrected_with_todo
+        else
+          return :uncorrected
+        end
+
+        apply_correction(corrector) if corrector
+        status
+      end
+
+      def disable_uncorrectable(range)
+        line = range.line
+        return unless currently_disabled_lines.add?(line)
+
+        disable_offense(range)
+      end
+
+      def range_from_node_or_range(node_or_range)
+        if node_or_range.respond_to?(:loc)
+          node_or_range.loc.expression
+        elsif node_or_range.is_a?(::Parser::Source::Range)
+          node_or_range
+        else
+          extra = ' (call `add_global_offense`)' if node_or_range.nil?
+          raise "Expected a Source::Range, got #{node_or_range.inspect}#{extra}"
+        end
+      end
+
+      def find_message(range, message)
+        annotate(message || message(range))
+      end
+
+      def annotate(message)
+        RuboCop::Cop::MessageAnnotator.new(
+          config, cop_name, cop_config, @options
+        ).annotate(message)
+      end
+
+      def file_name_matches_any?(file, parameter, default_result)
+        patterns = cop_config[parameter]
+        return default_result unless patterns
+
+        path = nil
+        patterns.any? do |pattern|
+          # Try to match the absolute path, as Exclude properties are absolute.
+          next true if match_path?(pattern, file)
+
+          # Try with relative path.
+          path ||= config.path_relative_to_config(file)
+          match_path?(pattern, path)
+        end
+      end
+
+      def enabled_line?(line_number)
+        return true if @options[:ignore_disable_comments] || !@processed_source
+
+        @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
+      end
+
+      def find_severity(_range, severity)
+        custom_severity || severity || default_severity
+      end
+
+      def default_severity
+        self.class.lint? ? :warning : :convention
+      end
+
+      def custom_severity
+        severity = cop_config['Severity']
+        return unless severity
+
+        if Severity::NAMES.include?(severity.to_sym)
+          severity.to_sym
+        else
+          message = "Warning: Invalid severity '#{severity}'. " \
+            "Valid severities are #{Severity::NAMES.join(', ')}."
+          warn(Rainbow(message).red)
+        end
+      end
+    end
+  end
+end