cuke_linter 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae22f6f11409b8b44b14680f1b4134e2deda49a8deca6a92ac78798f33588cd1
-  data.tar.gz: 443760f17fa6d22ba14c5264e0a26b3f71661afbb703505e9ca257cb3d677cfe
+  metadata.gz: cda526ecd0ab5cab7e5a1a588c5052cc9b15ca0779239289b043b5b0aa7160fa
+  data.tar.gz: 2a1b1eb4ad68db07f1b8deee8bee8614e1b5fb1048971ae6580e08d544c88424
 SHA512:
-  metadata.gz: 72af3e32ba1ee0a0c4b7b6dd939293b708f4e726e1858d43651d14aa3da8ba0266a4d8d0e6b1b6edd213c24a291c5adc601c736134cf6d1537811276ac29a67d
-  data.tar.gz: 583835b3d2f300f9d960711135aef2c5039062328bb5ba218cad1d37fae71c5dcdce5cc1394f6771281e09fbe740683822b98a5aecdd46c3ce843f12bc9d48dc
+  metadata.gz: be54da9ed9d7571302954de93506194b13b605790bcd140c421f00f70af02070b01e6c9af4cf1d51ceaa3b699b967ad60327fb06c85c6bf6cd2b993a26400381
+  data.tar.gz: b004e3c98632a9d510b828a238de24460c76201dc659ef780e98606225749b9feeb1568546ed1e9eda218a63e17873594bef8c2301cfa2886b03ddf733e6e855

data/CHANGELOG.md

@@ -8,6 +8,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [1.0.1] - 2020-05-06
+
+### Fixed
+ - Replaced some code that was not valid with earlier versions of Ruby 2.x, with which this gem is specified as being compatible.
+
 
 ## [1.0.0] - 2020-03-09
 
@@ -154,7 +159,8 @@ Nothing yet...
 - Custom linters, formatters, and command line usability
 
 
-[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v1.0.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v1.0.1...HEAD
+[1.0.1]: https://github.com/enkessler/cuke_linter/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/enkessler/cuke_linter/compare/v0.13.0...v1.0.0
 [0.13.0]: https://github.com/enkessler/cuke_linter/compare/v0.12.1...v0.13.0
 [0.12.1]: https://github.com/enkessler/cuke_linter/compare/v0.12.0...v0.12.1

data/README.md

@@ -104,7 +104,8 @@ class MyCustomLinter
     return nil unless model.is_a?(CukeModeler::Scenario)
 
     if model.name.empty?
-      { problem: 'Scenario has no name', location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }
+      { problem: 'Scenario has no name', 
+        location: "#{model.get_ancestor(:feature_file).path}:#{model.source_line}" }
     else
       nil
     end
@@ -134,13 +135,16 @@ output_path          = "#{__dir__}/my_report.txt"
 model_tree_root      = CukeModeler::Directory.new(Dir.pwd)
 additional_file_path = 'path/to/some.feature'
 
-# Providing the formatter twice so that it also is printed to the console
-CukeLinter.lint(linters: [linter], formatters: [[formatter], [formatter, output_path]], model_trees: [model_tree_root], file_paths: [additional_file_path])
+# Providing the formatter twice so that output also is printed to the console
+CukeLinter.lint(linters: [linter],
+                formatters: [[formatter], [formatter, output_path]],
+                model_trees: [model_tree_root],
+                file_paths: [additional_file_path])
 ```
 
 ### Configuration
 
-Rather than using the default linters or providing a custom set of of modified linters every time linting occurs, which linters to use and any linter specific modifications can be configured in a more static manner via a configuration file or setting the configuration directly in code. See [documentation](#documentation) for specifics.
+Rather than using the default linters or providing a custom set of of modified linters every time linting occurs, which linters to use and any linter specific modifications (such as choosing a non-default dialect) can be configured in a more static manner via a configuration file or setting the configuration directly in code. See [documentation](#documentation) for specifics.
 
 
 ### <a id="documentation"></a>Everything Else

data/cuke_linter.gemspec

@@ -1,40 +1,44 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "cuke_linter/version"
+require 'cuke_linter/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "cuke_linter"
+  spec.name          = 'cuke_linter'
   spec.version       = CukeLinter::VERSION
-  spec.authors       = ["Eric Kessler"]
-  spec.email         = ["morrow748@gmail.com"]
+  spec.authors       = ['Eric Kessler']
+  spec.email         = ['morrow748@gmail.com']
 
-  spec.summary       = %q{Lints feature files used by Cucumber and other similar frameworks.}
+  spec.summary       = 'Lints feature files used by Cucumber and other similar frameworks.'
   spec.homepage      = 'https://github.com/enkessler/cuke_linter'
-  spec.license       = "MIT"
+  spec.license       = 'MIT'
 
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files         = Dir.chdir(File.expand_path('', __dir__)) do
     source_controlled_files = `git ls-files -z`.split("\x0")
-    source_controlled_files.keep_if { |file| file =~ %r{^(lib|exe|testing/cucumber/features)} } + ['README.md', 'LICENSE.txt', 'CHANGELOG.md', 'cuke_linter.gemspec']
+    source_controlled_files.keep_if { |file| file =~ %r{^(lib|exe|testing/cucumber/features)} }
+    source_controlled_files + ['README.md', 'LICENSE.txt', 'CHANGELOG.md', 'cuke_linter.gemspec']
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.required_ruby_version = '~> 2.0'
 
   spec.add_runtime_dependency 'cuke_modeler', '>= 1.5', '< 3.0'
 
-  spec.add_development_dependency "bundler", "< 3.0"
-  spec.add_development_dependency "cucumber", "~> 3.0"
-  spec.add_development_dependency "racatt", "~> 1.0"
-  spec.add_development_dependency "rake", "~> 12.0"
-  spec.add_development_dependency "require_all", "~> 2.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency 'simplecov', '< 1.0.0'
+  spec.add_development_dependency 'bundler', '< 3.0'
+  spec.add_development_dependency 'childprocess', '~> 3.0'
   spec.add_development_dependency 'coveralls', '< 1.0.0'
+  spec.add_development_dependency 'cucumber', '~> 3.0'
+  spec.add_development_dependency 'cuke_slicer', '>= 2.0.2', '< 3.0'
+  spec.add_development_dependency 'ffi', '~> 1.0'
+  spec.add_development_dependency 'parallel', '~> 1.0'
   spec.add_development_dependency 'rainbow', '< 4.0.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'require_all', '~> 2.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '< 1.0.0'
+  spec.add_development_dependency 'simplecov', '< 1.0.0'
 end

data/exe/cuke_linter

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require "cuke_linter"
+require 'cuke_linter'
 require 'optparse'
 
 params              = {}
@@ -9,6 +9,7 @@ params[:formatters] = []
 params[:outs]       = []
 params[:requires]   = []
 
+# rubocop:disable Metrics/BlockLength
 parser = OptionParser.new do |options|
 
   options.set_summary_width(30)
@@ -68,6 +69,7 @@ parser = OptionParser.new do |options|
   end
 
 end
+# rubocop:enable Metrics/BlockLength
 
 begin
   parser.parse!

data/lib/cuke_linter.rb

@@ -1,7 +1,7 @@
 require 'yaml'
 require 'cuke_modeler'
 
-require "cuke_linter/version"
+require 'cuke_linter/version'
 require 'cuke_linter/formatters/pretty_formatter'
 require 'cuke_linter/linters/linter'
 require 'cuke_linter/linters/background_does_more_than_setup_linter'
@@ -29,233 +29,170 @@ require 'cuke_linter/linters/test_with_setup_step_after_action_step_linter'
 require 'cuke_linter/linters/test_with_setup_step_after_verification_step_linter'
 require 'cuke_linter/linters/test_with_setup_step_as_final_step_linter'
 require 'cuke_linter/linters/test_with_too_many_steps_linter'
+require 'cuke_linter/configuration'
+require 'cuke_linter/default_linters'
+require 'cuke_linter/gherkin'
+require 'cuke_linter/linter_registration'
 
 
 # The top level namespace used by this gem
-
 module CukeLinter
 
-  # The default keyword that is considered a 'Given' keyword
-  DEFAULT_GIVEN_KEYWORD = 'Given'.freeze
-  # The default keyword that is considered a 'When' keyword
-  DEFAULT_WHEN_KEYWORD = 'When'.freeze
-  # The default keyword that is considered a 'Then' keyword
-  DEFAULT_THEN_KEYWORD = 'Then'.freeze
-
-  @original_linters = { 'BackgroundDoesMoreThanSetupLinter'            => BackgroundDoesMoreThanSetupLinter.new,
-                        'ElementWithCommonTagsLinter'                  => ElementWithCommonTagsLinter.new,
-                        'ElementWithDuplicateTagsLinter'               => ElementWithDuplicateTagsLinter.new,
-                        'ElementWithTooManyTagsLinter'                 => ElementWithTooManyTagsLinter.new,
-                        'ExampleWithoutNameLinter'                     => ExampleWithoutNameLinter.new,
-                        'FeatureFileWithInvalidNameLinter'             => FeatureFileWithInvalidNameLinter.new,
-                        'FeatureFileWithMismatchedNameLinter'          => FeatureFileWithMismatchedNameLinter.new,
-                        'FeatureWithTooManyDifferentTagsLinter'        => FeatureWithTooManyDifferentTagsLinter.new,
-                        'FeatureWithoutDescriptionLinter'              => FeatureWithoutDescriptionLinter.new,
-                        'FeatureWithoutNameLinter'                     => FeatureWithoutNameLinter.new,
-                        'FeatureWithoutScenariosLinter'                => FeatureWithoutScenariosLinter.new,
-                        'OutlineWithSingleExampleRowLinter'            => OutlineWithSingleExampleRowLinter.new,
-                        'SingleTestBackgroundLinter'                   => SingleTestBackgroundLinter.new,
-                        'StepWithEndPeriodLinter'                      => StepWithEndPeriodLinter.new,
-                        'StepWithTooManyCharactersLinter'              => StepWithTooManyCharactersLinter.new,
-                        'TestShouldUseBackgroundLinter'                => TestShouldUseBackgroundLinter.new,
-                        'TestWithActionStepAsFinalStepLinter'          => TestWithActionStepAsFinalStepLinter.new,
-                        'TestWithBadNameLinter'                        => TestWithBadNameLinter.new,
-                        'TestWithNoActionStepLinter'                   => TestWithNoActionStepLinter.new,
-                        'TestWithNoNameLinter'                         => TestWithNoNameLinter.new,
-                        'TestWithNoVerificationStepLinter'             => TestWithNoVerificationStepLinter.new,
-                        'TestWithSetupStepAfterActionStepLinter'       => TestWithSetupStepAfterActionStepLinter.new,
-                        'TestWithSetupStepAfterVerificationStepLinter' => TestWithSetupStepAfterVerificationStepLinter.new,
-                        'TestWithSetupStepAsFinalStepLinter'           => TestWithSetupStepAsFinalStepLinter.new,
-                        'TestWithTooManyStepsLinter'                   => TestWithTooManyStepsLinter.new }
-
-
-  # Configures linters based on the given options
-  def self.load_configuration(config_file_path: nil, config: nil)
-    # TODO: define what happens if both a configuration file and a configuration are provided. Merge them or have direct config take precedence? Both?
-
-    unless config || config_file_path
-      config_file_path = "#{Dir.pwd}/.cuke_linter"
-      raise 'No configuration or configuration file given and no .cuke_linter file found' unless File.exist?(config_file_path)
-    end
-
-    config = config || YAML.load_file(config_file_path)
+  extend CukeLinter::Configuration
+  extend CukeLinter::LinterRegistration
 
-    common_config = config['AllLinters'] || {}
-    to_delete     = []
+  class << self
 
-    registered_linters.each_pair do |name, linter|
-      linter_config = config[name] || {}
-      final_config  = common_config.merge(linter_config)
+    # Lints the given model trees and file paths using the given linting objects and formatting
+    # the results with the given formatters and their respective output locations
+    def lint(file_paths: [], model_trees: [], linters: registered_linters.values, formatters: [[CukeLinter::PrettyFormatter.new]]) # rubocop:disable Metrics/LineLength
+      # TODO: Test this?
+      # Because directive memoization is based on a model's `#object_id` and Ruby reuses object IDs over the
+      # life of a program as objects are garbage collected, it is not safe to remember the IDs forever. However,
+      # models shouldn't get GC'd in the middle of the linting process and so the start of the linting process is
+      # a good time to reset things
+      @directives_for_feature_file = {}
 
-      disabled = (final_config.key?('Enabled') && !final_config['Enabled'])
+      model_trees                  = [CukeModeler::Directory.new(Dir.pwd)] if model_trees.empty? && file_paths.empty?
+      file_path_models             = collect_file_path_models(file_paths)
+      model_sets                   = model_trees + file_path_models
 
-      # Just save it for afterwards because modifying a collection while iterating through it is not a good idea
-      to_delete << name if disabled
+      linting_data = lint_models(model_sets, linters)
+      format_data(formatters, linting_data)
 
-      linter.configure(final_config) if linter.respond_to?(:configure)
+      linting_data
     end
 
-    to_delete.each { |linter_name| unregister_linter(linter_name) }
-  end
-
-  # Returns the registered linters to their default state
-  def self.reset_linters
-    @registered_linters = nil
-  end
-
-  # Registers for linting use the given linter object, tracked by the given name
-  def self.register_linter(linter:, name:)
-    self.registered_linters[name] = linter
-  end
-
-  # Unregisters the linter object tracked by the given name so that it is not used for linting
-  def self.unregister_linter(name)
-    self.registered_linters.delete(name)
-  end
 
-  # Lists the names of the currently registered linting objects
-  def self.registered_linters
-    @registered_linters ||= Marshal.load(Marshal.dump(@original_linters))
-  end
+    private
 
-  # Unregisters all currently registered linting objects
-  def self.clear_registered_linters
-    self.registered_linters.clear
-  end
 
-  # Lints the given model trees and file paths using the given linting objects and formatting the results with the given formatters and their respective output locations
-  def self.lint(file_paths: [], model_trees: [], linters: self.registered_linters.values, formatters: [[CukeLinter::PrettyFormatter.new]])
-
-    # TODO: Test this?
-    # Because directive memoization is based on a model's `#object_id` and Ruby reuses object IDs over the
-    # life of a program as objects are garbage collected, it is not safe to remember the IDs forever. However,
-    # models shouldn't get GC'd in the middle of the linting process and so the start of the linting process is
-    # a good time to reset things
-    @directives_for_feature_file = {}
-
-    model_trees                  = [CukeModeler::Directory.new(Dir.pwd)] if model_trees.empty? && file_paths.empty?
-    file_path_models             = file_paths.collect do |file_path|
-      # TODO: raise exception unless path exists?
-      case
-        when File.directory?(file_path)
+    def collect_file_path_models(file_paths)
+      file_paths.collect do |file_path|
+        # TODO: raise exception unless path exists?
+        if File.directory?(file_path)
           CukeModeler::Directory.new(file_path)
-        when File.file?(file_path) && File.extname(file_path) == '.feature'
+        elsif File.file?(file_path) && File.extname(file_path) == '.feature'
           CukeModeler::FeatureFile.new(file_path)
-        else
-          # Non-feature files are not modeled
-      end
-    end.compact # Compacting in order to get rid of any `nil` values left over from non-feature files
-
-    linting_data = []
-    model_sets   = model_trees + file_path_models
-
-    model_sets.each do |model_tree|
-      model_tree.each_model do |model|
-        applicable_linters = relevant_linters_for_model(linters, model)
-        applicable_linters.each do |linter|
-          # TODO: have linters lint only certain types of models?
-          #         linting_data.concat(linter.lint(model)) if relevant_model?(linter, model)
-
-          result = linter.lint(model)
-
-          if result
-            result[:linter] = linter.name
-            linting_data << result
-          end
         end
-      end
+      end.compact # Compacting in order to get rid of any `nil` values left over from non-feature files
     end
 
-    formatters.each do |formatter_output_pair|
-      formatter = formatter_output_pair[0]
-      location  = formatter_output_pair[1]
-
-      formatted_data = formatter.format(linting_data)
-
-      if location
-        File.write(location, formatted_data)
-      else
-        puts formatted_data
+    def lint_models(model_sets, linters)
+      [].tap do |linting_data|
+        model_sets.each do |model_tree|
+          model_tree.each_model do |model|
+            applicable_linters = relevant_linters_for_model(linters, model)
+            applicable_linters.each do |linter|
+              # TODO: have linters lint only certain types of models?
+              #         linting_data.concat(linter.lint(model)) if relevant_model?(linter, model)
+
+              result = linter.lint(model)
+
+              if result
+                result[:linter] = linter.name
+                linting_data << result
+              end
+            end
+          end
+        end
       end
     end
 
-    linting_data
-  end
+    def relevant_linters_for_model(base_linters, model)
+      feature_file_model = model.get_ancestor(:feature_file)
 
+      # Linter directives are not applicable for directory and feature file models. Every other
+      # model type should have a feature file ancestor from which to grab linter directive comments.
+      return base_linters if feature_file_model.nil?
 
-  def self.relevant_linters_for_model(base_linters, model)
-    feature_file_model = model.get_ancestor(:feature_file)
+      linter_modifications_for_model = {}
 
-    # Linter directives are not applicable for directory and feature file models. Every other model type should have a feature file ancestor from which to grab linter directive comments.
-    return base_linters if feature_file_model.nil?
+      linter_directives_for_feature_file(feature_file_model).each do |directive|
+        # Assuming that the directives are in the same order that they appear in the file
+        break if directive[:source_line] > model.source_line
 
-    linter_modifications_for_model = {}
+        linter_modifications_for_model[directive[:linter_class]] = directive[:enabled_status]
+      end
 
-    linter_directives_for_feature_file(feature_file_model).each do |directive|
-      # Assuming that the directives are in the same order that they appear in the file
-      break if directive[:source_line] > model.source_line
+      disabled_linter_classes = linter_modifications_for_model.reject { |_name, status| status }.keys
+      enabled_linter_classes  = linter_modifications_for_model.select { |_name, status| status }.keys
 
-      linter_modifications_for_model[directive[:linter_class]] = directive[:enabled_status]
+      determine_final_linters(base_linters, disabled_linter_classes, enabled_linter_classes)
     end
 
-    disabled_linter_classes = linter_modifications_for_model.reject { |_name, status| status }.keys
-    enabled_linter_classes  = linter_modifications_for_model.select { |_name, status| status }.keys
+    def determine_final_linters(base_linters, disabled_linter_classes, enabled_linter_classes)
+      final_linters = base_linters.reject { |linter| disabled_linter_classes.include?(linter.class) }
 
-    final_linters = base_linters.reject { |linter| disabled_linter_classes.include?(linter.class) }
-    enabled_linter_classes.each do |clazz|
-      final_linters << dynamic_linters[clazz] unless final_linters.map(&:class).include?(clazz)
-    end
-
-    final_linters
-  end
+      enabled_linter_classes.each do |clazz|
+        final_linters << dynamic_linters[clazz] unless final_linters.map(&:class).include?(clazz)
+      end
 
-  private_class_method(:relevant_linters_for_model)
+      final_linters
+    end
 
+    def linter_directives_for_feature_file(feature_file_model)
+      # IMPORTANT ASSUMPTION: Models never change during the life of a linting, so data only has to be gathered once
+      existing_directives = @directives_for_feature_file[feature_file_model.object_id]
 
-  def self.linter_directives_for_feature_file(feature_file_model)
-    # IMPORTANT ASSUMPTION: Models never change during the life of a linting, so data only has to be gathered once
-    return @directives_for_feature_file[feature_file_model.object_id] if @directives_for_feature_file[feature_file_model.object_id]
+      return existing_directives if existing_directives
 
+      directives = gather_directives_in_feature(feature_file_model)
 
-    @directives_for_feature_file[feature_file_model.object_id] = []
+      # Make sure that the directives are in the same order as they appear in the source file
+      directives = directives.sort_by { |a| a[:source_line] }
 
-    feature_file_model.comments.each do |comment|
-      pieces = comment.text.match(/#\s*cuke_linter:(disable|enable)\s+(.*)/)
-      next unless pieces # Skipping non-directive file comments
+      @directives_for_feature_file[feature_file_model.object_id] = directives
+    end
 
-      linter_classes = pieces[2].gsub(',', ' ').split(' ')
-      linter_classes.each do |clazz|
-        @directives_for_feature_file[feature_file_model.object_id] << { linter_class:   Kernel.const_get(clazz),
-                                                                        enabled_status: pieces[1] != 'disable',
-                                                                        source_line:    comment.source_line }
+    def gather_directives_in_feature(feature_file_model)
+      [].tap do |directives|
+        feature_file_model.comments.each do |comment|
+          pieces = comment.text.match(/#\s*cuke_linter:(disable|enable)\s+(.*)/)
+          next unless pieces # Skipping non-directive file comments
+
+          linter_classes = pieces[2].tr(',', ' ').split(' ')
+          linter_classes.each do |clazz|
+            directives << { linter_class:   Kernel.const_get(clazz),
+                            enabled_status: pieces[1] != 'disable',
+                            source_line:    comment.source_line }
+          end
+        end
       end
     end
 
-    # Make sure that the directives are in the same order as they appear in the source file
-    @directives_for_feature_file[feature_file_model.object_id] = @directives_for_feature_file[feature_file_model.object_id].sort { |a, b| a[:source_line] <=> b[:source_line] }
+    def dynamic_linters
+      # No need to keep making new ones over and over...
+      @dynamic_linters ||= Hash.new { |hash, key| hash[key] = key.new }
+      # return @dynamic_linters if @dynamic_linters
+      #
+      # @dynamic_linters = {}
+    end
 
+    def format_data(formatters, linting_data)
+      formatters.each do |formatter_output_pair|
+        formatter = formatter_output_pair[0]
+        location  = formatter_output_pair[1]
 
-    @directives_for_feature_file[feature_file_model.object_id]
-  end
+        formatted_data = formatter.format(linting_data)
 
-  private_class_method(:linter_directives_for_feature_file)
+        if location
+          File.write(location, formatted_data)
+        else
+          puts formatted_data
+        end
+      end
+    end
 
-  def self.dynamic_linters
-    # No need to keep making new ones over and over...
-    @dynamic_linters ||= Hash.new { |hash, key| hash[key] = key.new }
-    # return @dynamic_linters if @dynamic_linters
+    # Not linting unused code
+    # rubocop:disable Metrics/LineLength
+    #   def self.relevant_model?(linter, model)
+    #     model_classes = linter.class.target_model_types.map { |type| CukeModeler.const_get(type.to_s.capitalize.chop) }
+    #     model_classes.any? { |clazz| model.is_a?(clazz) }
+    #   end
     #
-    # @dynamic_linters = {}
-  end
-
-  private_class_method(:dynamic_linters)
-
-
-# #   def self.relevant_model?(linter, model)
-# #     model_classes = linter.class.target_model_types.map { |type| CukeModeler.const_get(type.to_s.capitalize.chop) }
-# #     model_classes.any? { |clazz| model.is_a?(clazz) }
-# #   end
-# #
-# #   private_class_method(:relevant_model?)
+    #   private_class_method(:relevant_model?)
+    # rubocop:enable Metrics/LineLength
 
+  end
 end