reek 1.3.4 → 1.3.5

data/lib/reek/spec/should_reek.rb

@@ -8,11 +8,8 @@ module Reek
     # An rspec matcher that matches when the +actual+ has code smells.
     #
     class ShouldReek        # :nodoc:
-      def initialize(config_files = [])
-        @config_files = config_files
-      end
       def matches?(actual)
-        @examiner = Examiner.new(actual, @config_files)
+        @examiner = Examiner.new(actual)
         @examiner.smelly?
       end
       def failure_message_for_should
@@ -28,7 +25,7 @@ module Reek
     # Returns +true+ if and only if the target source code contains smells.
     #
     def reek
-      ShouldReek.new(Dir['config/*.reek'])
+      ShouldReek.new
     end
   end
 end

data/lib/reek/version.rb

@@ -1,3 +1,3 @@
 module Reek
-  VERSION = '1.3.4'
+  VERSION = '1.3.5'
 end

data/reek.gemspec

@@ -28,7 +28,7 @@ and reports any code smells it finds.
 
   s.add_runtime_dependency(%q<ruby_parser>, ["~> 3.2"])
   s.add_runtime_dependency(%q<sexp_processor>)
-  s.add_runtime_dependency(%q<ruby2ruby>, ["~> 2.0.2"])
+  s.add_runtime_dependency(%q<ruby2ruby>, ["~> 2.0.7"])
 
   s.add_development_dependency(%q<bundler>, ["~> 1.1"])
   s.add_development_dependency(%q<rake>)

data/spec/matchers/smell_of_matcher.rb

@@ -20,7 +20,6 @@ module SmellOfMatcher
       detect_smells
 
       return false if no_smells_found?
-      return false if wrong_smell_class_found?
       return false if wrong_number_of_smells_found?
       return false if wrong_smell_details_found?
 
@@ -48,25 +47,23 @@ module SmellOfMatcher
       end
     end
 
-    def wrong_smell_class_found?
-      @actual_smells.each do |smell|
-        if smell.smell_class != @klass::SMELL_CLASS ||
-          smell.subclass != @klass::SMELL_SUBCLASS
-          @reason = "Found #{smell.smell_class}/#{smell.subclass}"
-          return true
-        end
-      end
-      false
-    end
-
     def wrong_number_of_smells_found?
-      expected_number_of_smells = @expected_smells.empty? ? 1 : @expected_smells.length
-      if expected_number_of_smells != @actual_smells.length
-        @reason = "expected #{expected_number_of_smells} smell(s), found #{@actual_smells.length}"
+      return false if @expected_smells.empty?
+
+      if expected_number_of_smells != actual_number_of_smells
+        @reason = "expected #{expected_number_of_smells} smell(s), found #{actual_number_of_smells}"
         true
       end
     end
 
+    def expected_number_of_smells
+      @expected_number_of_smells ||= @expected_smells.length
+    end
+
+    def actual_number_of_smells
+      @actual_number_of_smells ||= @actual_smells.length
+    end
+
     def wrong_smell_details_found?
       @expected_smells.zip(@actual_smells).each do |expected_smell, actual_smell|
         expected_smell.each do |key, value|

data/spec/reek/cli/report_spec.rb

@@ -9,7 +9,9 @@ describe QuietReport, " when empty" do
   context 'empty source' do
     it 'has an empty quiet_report' do
       examiner = Examiner.new('')
-      QuietReport.new.report(examiner).should == ''
+      qr = QuietReport.new
+      qr.add_examiner(examiner)
+      qr.gather_results.should == []
     end
   end
 
@@ -17,14 +19,16 @@ describe QuietReport, " when empty" do
     before :each do
       examiner = Examiner.new('def simple(a) a[3] end')
       rpt = QuietReport.new
-      @lines = rpt.report(examiner).split("\n")
+      @result = rpt.add_examiner(examiner).gather_results.first
     end
-    it 'has a header and a list of smells' do
-      @lines.should have_at_least(3).lines
+
+    it 'has a header' do
+      @result.should match('string -- 2 warnings')
     end
+
     it 'should mention every smell name' do
-      @lines[0].should match('[Utility Function]')
-      @lines[1].should match('[Feature Envy]')
+      @result.should match('[UncommunicativeParameterName]')
+      @result.should match('[Feature Envy]')
     end
   end
 end

data/spec/reek/core/code_parser_spec.rb

@@ -34,9 +34,3 @@ EOS
     src.should_not reek
   end
 end
-
-describe CodeParser do
-  it 'copes with a yield to an ivar' do
-    'def options() ozz.on { |@list| @prompt = !@list } end'.should_not reek
-  end
-end

data/spec/reek/smells/control_parameter_spec.rb

@@ -12,22 +12,209 @@ describe ControlParameter do
 
   it_should_behave_like 'SmellDetector'
 
-  context 'conditional on a parameter' do
+  it 'should not report a ternary check on an ivar' do
+    src = 'def simple(arga) @ivar ? arga : 3 end'
+    src.should_not smell_of(ControlParameter)
+  end
+
+  it 'should not report a ternary check on a lvar' do
+    src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
+    src.should_not smell_of(ControlParameter)
+  end
+
+  it 'should not report when parameter is unused' do
+    src = 'def simple(arg) test = 1 end'
+    src.should_not smell_of(ControlParameter)
+  end
+
+  it 'should not report when parameter is used inside conditional' do
+    src = 'def simple(arg) if true then puts arg end end'
+    src.should_not smell_of(ControlParameter)
+  end
+
+  it 'should not report when used in first conditional but not second' do
+    src = <<EOS
+def things(arg)
+  if arg
+    puts arg
+  end
+  if arg
+    puts 'a'
+  end
+end
+EOS
+    src.should_not smell_of(ControlParameter)
+  end
+
+  it 'should not report when used in second conditional but not first' do
+    src = <<EOS
+def things(arg)
+  if arg
+    puts 'a'
+  end
+  if arg
+    puts arg
+  end
+end
+EOS
+    src.should_not smell_of(ControlParameter)
+  end
+
+  it 'should not report on complex non smelly method' do
+    src = <<EOS
+  def self.guess(arg)
+    case arg
+    when ""
+      t = self
+    when "a"
+      t = Switch::OptionalArgument
+    when "b"
+      t = Switch::PlacedArgument
+    else
+      t = Switch::RequiredArgument
+    end
+    self >= t or incompatible_argument_styles(arg, t)
+    t
+  end
+EOS
+    src.should_not smell_of(ControlParameter)
+  end
+
+  context 'parameter only used to determine code path' do
     it 'should report a ternary check on a parameter' do
       src = 'def simple(arga) arga ? @ivar : 3 end'
       src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arga')
     end
-    it 'should not report a ternary check on an ivar' do
-      src = 'def simple(arga) @ivar ? arga : 3 end'
+
+    it 'should spot a couple inside a block' do
+      src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on an if statement modifier' do
+      src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') if arg end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on an unless statement modifier' do
+      src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') unless arg end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on if control expression' do
+      src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => \'A\') end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on if control expression with &&' do
+      src = 'def simple(arg) if arg && true then puts "arg" end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on if control expression with preceding &&' do
+      src = 'def simple(arg) if true && arg then puts "arg" end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on if control expression with two && conditions' do
+      src = 'def simple(a) ag = {}; if a && true && true then puts "2" end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'a')
+    end
+
+    it 'should report on if control expression with ||' do
+      src = 'def simple(arg) args = {}; if arg || true then puts "arg" end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on if control expression with or' do
+      src = 'def simple(arg) args = {}; if arg or true then puts "arg" end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on && notation' do
+      src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => \'A\') end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on || notation' do
+      src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => \'A\') end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on case statement' do
+      src = 'def simple(arg) case arg when nil; nil when false; nil else nil end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report when the argument is a hash on which we access a key' do
+      src = 'def simple(arg) if arg[\'a\'] then puts \'a\' else puts \'b\' end end'
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on nested if statements that are both control parameters' do
+      src = <<EOS
+def nested(arg)
+  if arg
+    puts 'a'
+    puts 'b' if arg
+  end
+end
+EOS
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+
+    it 'should report on nested if statements where the inner if is a control parameter' do
+      src = <<EOS
+def nested(arg)
+  if true
+    puts 'a'
+    puts 'b' if arg
+  end
+end
+EOS
+      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+    end
+  end
+
+  context 'parameter used besides determining code path' do
+    it 'should not report on if conditional expression' do
+      src = 'def simple(arg) if arg then use(arg) else use(@other) end end'
       src.should_not smell_of(ControlParameter)
     end
-    it 'should not report a ternary check on a lvar' do
-      src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
+
+    it 'should not report on an if statement modifier' do
+      src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) if arg end'
       src.should_not smell_of(ControlParameter)
     end
-    it 'should spot a couple inside a block' do
-      src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
-      src.should smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+
+    it 'should not report on an unless statement modifier' do
+      src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) unless arg end'
+      src.should_not smell_of(ControlParameter)
+    end
+
+    it 'should not report on if control expression' do
+      src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => arg) end end'
+      src.should_not smell_of(ControlParameter)
+    end
+
+    it 'should not report on if control expression with &&' do
+      src = 'def simple(arg) if arg && true then puts arg end end'
+      src.should_not smell_of(ControlParameter)
+    end
+
+    it 'should not report on && notation' do
+      src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => arg) end'
+      src.should_not smell_of(ControlParameter)
+    end
+
+    it 'should not report on || notation' do
+      src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => arg) end'
+      src.should_not smell_of(ControlParameter)
+    end
+
+    it 'should not report when parameter is used outside conditional' do
+      src = 'def simple(arg) puts arg; if arg then @a = 1 end end'
+      src.should_not smell_of(ControlParameter)
     end
   end
 

data/spec/reek/smells/data_clump_spec.rb

@@ -42,7 +42,7 @@ EOS
     it 'reports the number of occurrences' do
       @smells[0].smell[DataClump::OCCURRENCES_KEY].should == 3
     end
-    it 'reports all parameters' do
+    it 'reports all methods' do
       @smells[0].smell[DataClump::METHODS_KEY].should == ['first', 'second', 'third']
     end
     it 'reports the declaration line numbers' do
@@ -56,7 +56,7 @@ EOS
     end
   end
 
-  it 'reports 3 swapped pairs in a class' do
+  it 'reports 3 swapped pairs' do
     src = <<EOS
 #{@context} Scrunch
   def one(pa, pb) @field == :sym ? 0 : 3; end
@@ -68,7 +68,7 @@ EOS
       DataClump::PARAMETERS_KEY => ['pa', 'pb']})
   end
 
-  it 'reports 3 identical parameter sets in a class' do
+  it 'reports 3 identical parameter sets' do
     src = <<EOS
 #{@context} Scrunch
   def first(pa, pb, pc) @field == :sym ? 0 : 3; end
@@ -115,6 +115,31 @@ end
 EOS
     src.should smell_of(DataClump, DataClump::OCCURRENCES_KEY => 5)
   end
+
+  it 'correctly checks number of occurences' do
+    src = <<-EOS
+      #{@context} Smelly
+        def fa(p1, p2, p3) end
+        def fb(p2, p3, p4) end
+        def fc(p3, p4, p5) end
+        def fd(p4, p5, p1) end
+        def fe(p5, p1, p2) end
+      end
+    EOS
+    src.should_not smell_of(DataClump)
+  end
+
+  it 'detects clumps smaller than the total number of arguments' do
+    src = <<-EOS
+      #{@context} Smelly
+        def fa(p1, p2, p3) end
+        def fb(p1, p3, p2) end
+        def fc(p4, p1, p2) end
+      end
+    EOS
+    src.should smell_of(DataClump,
+                        { DataClump::PARAMETERS_KEY => %w(p1 p2) })
+  end
 end
 
 describe DataClump do

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -23,19 +23,19 @@ describe UncommunicativeMethodName do
 
   ['x', 'x2', 'method2'].each do |method_name|
     context 'with a bad name' do
-      before :each do
-        src = 'def x() end'
+      before do
+        src = "def #{method_name}; end"
         ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-        @smells = @detector.examine_context(ctx)
-        @warning = @smells[0]
+        smells = @detector.examine_context(ctx)
+        @warning = smells[0]
       end
 
       it_should_behave_like 'common fields set correctly'
 
       it 'reports the correct values' do
-        @smells[0].smell[UncommunicativeMethodName::METHOD_NAME_KEY].should == 'x'
-        @smells[0].lines.should == [1]
-        @smells[0].context.should == 'x'
+        @warning.smell[UncommunicativeMethodName::METHOD_NAME_KEY].should == method_name
+        @warning.lines.should == [1]
+        @warning.context.should == method_name
       end
     end
   end

data/spec/reek/source/sexp_extensions_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper'
+require 'reek/source/sexp_extensions'
+
+include Reek::Source
+
+describe SexpExtensions::DefnNode do
+  context 'with no parameters' do
+    before :each do
+      @node = s(:defn, :hello, s(:args))
+      @node.extend(SexpExtensions::DefnNode)
+    end
+    it 'has no arg names' do
+      @node.arg_names.should == s()
+    end
+    it 'has no parameter names' do
+      @node.parameter_names.should == s()
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'hello'
+    end
+  end
+
+  context 'with 1 parameter' do
+    before :each do
+      @node = s(:defn, :hello, s(:args, :param))
+      @node.extend(SexpExtensions::DefnNode)
+    end
+    it 'has 1 arg name' do
+      @node.arg_names.should == s(:param)
+    end
+    it 'has 1 parameter name' do
+      @node.parameter_names.should == s(:param)
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'hello'
+    end
+  end
+
+  context 'with a block' do
+    before :each do
+      @node = s(:defn, :hello, s(:args, :param, :"&blk"))
+      @node.extend(SexpExtensions::DefnNode)
+    end
+    it 'has 1 arg name' do
+      @node.arg_names.should == s(:param)
+    end
+    it 'has 2 parameter names' do
+      @node.parameter_names.should == s(:param, :"&blk")
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'hello'
+    end
+  end
+
+  context 'with 1 defaulted parameter' do
+    before :each do
+      @node = s(:defn, :hello, s(:args, s(:lasgn, :param, s(:array))))
+      @node.extend(SexpExtensions::DefnNode)
+    end
+    it 'has 1 arg name' do
+      @node.arg_names.should == s(:param)
+    end
+    it 'has 1 parameter name' do
+      @node.parameter_names.should == s(:param)
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'hello'
+    end
+  end
+
+  context 'with a body with 2 statements' do
+    before :each do
+      @node = s(:defn, :hello, s(:args), s(:first), s(:second))
+      @node.extend(SexpExtensions::DefnNode)
+    end
+
+    it 'has 2 body statements' do
+      @node.body.should == s(s(:first), s(:second))
+    end
+
+    it 'has a body extended with SexpNode' do
+      b = @node.body
+      (class << b; self; end).ancestors.first.should == SexpNode
+    end
+  end
+end
+
+describe SexpExtensions::DefsNode do
+  context 'with no parameters' do
+    before :each do
+      @node = s(:defs, :obj, :hello, s(:args))
+      @node.extend(SexpExtensions::DefsNode)
+    end
+    it 'has no arg names' do
+      @node.arg_names.should == s()
+    end
+    it 'has no parameter names' do
+      @node.parameter_names.should == s()
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#obj.hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'obj.hello'
+    end
+  end
+
+  context 'with 1 parameter' do
+    before :each do
+      @node = s(:defs, :obj, :hello, s(:args, :param))
+      @node.extend(SexpExtensions::DefsNode)
+    end
+    it 'has 1 arg name' do
+      @node.arg_names.should == s(:param)
+    end
+    it 'has 1 parameter name' do
+      @node.parameter_names.should == s(:param)
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#obj.hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'obj.hello'
+    end
+  end
+
+  context 'with a block' do
+    before :each do
+      @node = s(:defs, :obj, :hello, s(:args, :param, :"&blk"))
+      @node.extend(SexpExtensions::DefsNode)
+    end
+    it 'has 1 arg name' do
+      @node.arg_names.should == s(:param)
+    end
+    it 'has 2 parameter names' do
+      @node.parameter_names.should == s(:param, :"&blk")
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#obj.hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'obj.hello'
+    end
+  end
+
+  context 'with 1 defaulted parameter' do
+    before :each do
+      @node = s(:defs, :obj, :hello, s(:args, s(:lasgn, :param, s(:array))))
+      @node.extend(SexpExtensions::DefsNode)
+    end
+    it 'has 1 arg name' do
+      @node.arg_names.should == s(:param)
+    end
+    it 'has 1 parameter name' do
+      @node.parameter_names.should == s(:param)
+    end
+    it 'includes outer scope in its full name' do
+      @node.full_name('Fred').should == 'Fred#obj.hello'
+    end
+    it 'includes no marker in its full name with empty outer scope' do
+      @node.full_name('').should == 'obj.hello'
+    end
+  end
+
+  context 'with a body with 2 statements' do
+    before :each do
+      @node = s(:defs, s(:self), :hello, s(:args), s(:first), s(:second))
+      @node.extend(SexpExtensions::DefsNode)
+    end
+
+    it 'has 2 body statements' do
+      @node.body.should == s(s(:first), s(:second))
+    end
+
+    it 'has a body extended with SexpNode' do
+      b = @node.body
+      (class << b; self; end).ancestors.first.should == SexpNode
+    end
+  end
+end
+
+describe SexpExtensions::CallNode do
+  context 'with no parameters' do
+    before :each do
+      @node = s(:call, nil, :hello)
+      @node.extend(SexpExtensions::CallNode)
+    end
+    it 'has no parameter names' do
+      @node.parameter_names.should == nil
+    end
+  end
+
+  context 'with 1 literal parameter' do
+    before :each do
+      @node = s(:call, nil, :hello, s(:lit, :param))
+      @node.extend(SexpExtensions::CallNode)
+    end
+    it 'has 1 argument name' do
+      @node.arg_names.should == [:param]
+    end
+  end
+
+  context 'with 2 literal parameters' do
+    before :each do
+      @node = s(:call, nil, :hello, s(:lit, :x), s(:lit, :y))
+      @node.extend(SexpExtensions::CallNode)
+    end
+    it 'has 2 argument names' do
+      @node.arg_names.should == [:x, :y]
+    end
+  end
+end
+
+describe SexpExtensions::IterNode do
+  context 'with no parameters' do
+    before :each do
+      @node = s(:iter, s(), s(:args), s())
+      @node.extend(SexpExtensions::IterNode)
+    end
+    it 'has no parameter names' do
+      @node.parameter_names.should == []
+    end
+  end
+
+  context 'with 1 parameter' do
+    before :each do
+      @node = s(:iter, s(), s(:args, :param), s())
+      @node.extend(SexpExtensions::IterNode)
+    end
+    it 'has 1 parameter name' do
+      @node.parameter_names.should == s(:param)
+    end
+  end
+
+  context 'with 2 parameters' do
+    before :each do
+      @node = s(:iter, s(), s(:args, :x, :y), s())
+      @node.extend(SexpExtensions::IterNode)
+    end
+    it 'has 2 parameter names' do
+      @node.parameter_names.should == [:x, :y]
+    end
+  end
+end
+
+describe SexpExtensions::ModuleNode do
+  context 'with a simple name' do
+    subject do
+      mod = ast(:module, :Fred, nil)
+      mod
+    end
+    its(:name) { should == :Fred }
+    its(:simple_name) { should == :Fred }
+    its(:text_name) { should == 'Fred' }
+    it 'has a simple full_name' do
+      subject.full_name('').should == 'Fred'
+    end
+    it 'has a fq full_name' do
+      subject.full_name('Blimey::O::Reilly').should == 'Blimey::O::Reilly::Fred'
+    end
+  end
+
+  context 'with a scoped name' do
+    subject do
+      mod = ast(:module, s(:colon2, s(:const, :Foo), :Bar), nil)
+      mod
+    end
+    its(:name) { should == s(:colon2, s(:const, :Foo), :Bar) }
+    its(:simple_name) { should == :Bar }
+    its(:text_name) { should == 'Foo::Bar' }
+    it 'has a simple full_name' do
+      subject.full_name('').should == 'Foo::Bar'
+    end
+    it 'has a fq full_name' do
+      subject.full_name('Blimey::O::Reilly').should == 'Blimey::O::Reilly::Foo::Bar'
+    end
+  end
+end