license_finder 0.6.0 → 0.7.0

data/license_finder.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = "license_finder"
-  s.version     = "0.6.0"
+  s.version     = "0.7.0"
   s.authors     = ["Jacob Maine", "Matthew Kane Parker", "Ian Lesperance", "David Edwards", "Paul Meskers"]
   s.email       = ["brent@pivotalabs.com"]
   s.homepage    = "https://github.com/pivotal/LicenseFinder"
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "bundler"
   s.add_development_dependency "rails", ">=3"
-  %w(rspec rr rake cucumber rails pry capybara).each do |gem|
+  %w(rspec rake cucumber rails pry capybara).each do |gem|
     s.add_development_dependency gem
   end
 

data/{README.markdown → readme.md}

@@ -10,7 +10,7 @@ With bundler it's easy for your project to depend on many gems.  This decomposit
 Add license_finder to your Rails project's Gemfile and `bundle`:
 
 ```ruby
-gem 'license_finder'
+gem 'license_finder', git: "https://github.com/pivotal/LicenseFinder.git"
 ```
 
 ## Usage
@@ -62,11 +62,26 @@ unapproved dependency to the project.
 It will also merge in an existing dependencies.yml file, if one exists (i.e., you've previously run this command
 and then edited the resulting file).
 
+### Manually recording licenses
+
+When you have dependencies marked as having an 'other' license, `license_finder` will output
+the license and readme file locations for the dependency, allowing you to manually research what the actual
+license is. Once this has been established, you can record this information with the `-l` option
+as such:
+
+```sh
+$ license_finder -l MIT my_unknown_dependency
+```
+
+This command would assign the MIT license to the dependency `my_unknown_dependency`.
+
 ### Manually approving dependencies
 
 Whenever you have a dependency that falls outside of your whitelist, `license_finder` will tell you.
-If your business decides that this is an acceptable risk, you can manually approve the dependency by finding its
-section in the `dependencies.yml` file and setting its `approved` attribute to true. For example, lets assume you've only
+If your business decides that this is an acceptable risk, you can manually approve the dependency by using the `-a` or
+`--approve` option of the `license_finder` command.
+
+For example, lets assume you've only
 whitelisted the "MIT" license in your `config/license_finder.yml`. You then add the 'awesome_gpl_gem' to your Gemfile,
 which we'll assume is licensed with the `GPL` license. You then run `license_finder` and see
 the gem listed in the output:
@@ -75,14 +90,10 @@ the gem listed in the output:
 awesome_gpl_gem, 1.0.0, GPL
 ```
 
-Your business tells you that in this case, it's acceptable to use this gem. You should now update your `dependencies.yml`
-file, setting the `approved` attribute to `true` for the `awesome_gpl_gem` section:
+Your business tells you that in this case, it's acceptable to use this gem. You now run:
 
-```yaml
-- name: awesome_gpl_gem
-  version: 1.0.0
-  license: GPL
-  approved: true
+```sh
+$ bundle exec license_finder -a awesome_gpl_gem
 ```
 
 If you rerun `license_finder`, you should no longer see `awesome_gpl_gem` in the output.
@@ -141,4 +152,4 @@ And add a `LICENSE` file to your gem that contains your license text.
 
 ## License
 
-LicenseFinder is released under the terms of the MIT License. http://www.opensource.org/licenses/mit-license
+LicenseFinder is released under the MIT License. http://www.opensource.org/licenses/mit-license

data/spec/lib/license_finder/bundle_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+module LicenseFinder
+  describe Bundle do
+    def build_gemspec(name, version, dependency=nil)
+      Gem::Specification.new do |s|
+        s.name = name
+        s.version = version
+        s.summary = 'summary'
+        s.description = 'description'
+
+        if dependency
+          s.add_dependency dependency
+        end
+      end
+    end
+
+    describe '.from_bundler(bundle)' do
+      let(:definition) do
+        double('definition', {
+          :dependencies => [],
+          :groups => [],
+          :specs_for => [
+            build_gemspec('gem1', '1.2.3'),
+            build_gemspec('gem2', '0.4.2')
+          ]
+        })
+      end
+
+      subject do
+        Bundle.new(definition).gems.map(&:to_dependency)
+      end
+
+      its(:count) { should == 2 }
+
+      it "should have 2 dependencies" do
+        subject.size.should == 2
+      end
+
+      context "when initialized with a parent and child gem" do
+        before do
+          definition.stub(:specs_for).and_return([
+            build_gemspec('gem1', '1.2.3', 'gem2'),
+            build_gemspec('gem2', '0.4.2')
+          ])
+        end
+
+        it "should update the child dependency with its parent data" do
+          gem1 = subject.first
+          gem2 = subject.last
+
+          gem2.parents.should == [gem1.name]
+          gem1.children.should == [gem2.name]
+        end
+      end
+    end
+  end
+end

data/spec/lib/license_finder/bundle_syncer_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+module LicenseFinder
+  describe BundleSyncer do
+    describe "#sync!" do
+      it "should delegate the bundled dependencies and the persisted bundled dependencies to the source syncer" do
+        gem = double :gem, :to_dependency => double(:gem_dependency)
+        bundled_dep = double :bundled_dep, source: "bundle"
+        manual_dep  = double :manual_dep, source: nil
+        syncer = double :source_syncer
+
+        Bundle.stub_chain(:new, :gems).and_return [gem]
+        Dependency.stub(:all).and_return [bundled_dep, manual_dep]
+        SourceSyncer.should_receive(:new).with([gem.to_dependency], [bundled_dep]).and_return syncer
+        syncer.should_receive(:sync!)
+
+        BundleSyncer.sync!
+      end
+    end
+  end
+end
+

data/spec/lib/license_finder/bundled_gem_spec.rb

@@ -10,6 +10,8 @@ describe LicenseFinder::BundledGem do
       s.summary = 'summary'
       s.description = 'description'
       s.homepage = 'homepage'
+
+      s.add_dependency 'foo'
     end
   end
 
@@ -25,26 +27,26 @@ describe LicenseFinder::BundledGem do
   describe "#determine_license" do
     subject do
       details = LicenseFinder::BundledGem.new(gemspec)
-      stub(details).license_files { [license_file] }
+      details.stub(:license_files).and_return([license_file])
       details
     end
 
     let(:license_file) { LicenseFinder::PossibleLicenseFile.new('gem', 'gem/license/path') }
 
     it "returns the license from the gemspec if provided" do
-      stub(gemspec).license { "Some License" }
+      gemspec.stub(:license).and_return('Some License')
 
       subject.determine_license.should == "Some License"
     end
 
     it "returns the matched license if detected" do
-      stub(license_file).license { "Detected License" }
+      license_file.stub(:license).and_return('Detected License')
 
       subject.determine_license.should == "Detected License"
     end
 
     it "returns 'other' otherwise" do
-      stub(license_file).license { nil }
+      license_file.stub(:license).and_return(nil)
 
       subject.determine_license.should == "other"
     end
@@ -56,14 +58,14 @@ describe LicenseFinder::BundledGem do
     end
 
     it "includes files with names like LICENSE, License or COPYING" do
-      stub(gemspec).full_gem_path { fixture_path('license_names') }
+      gemspec.stub(:full_gem_path).and_return(fixture_path('license_names'))
 
       subject.license_files.map(&:file_name).should =~
         %w[COPYING.txt LICENSE Mit-License README.rdoc Licence.rdoc]
     end
 
     it "includes files deep in the hierarchy" do
-      stub(gemspec).full_gem_path { fixture_path('nested_gem') }
+      gemspec.stub(:full_gem_path).and_return(fixture_path('nested_gem'))
 
       subject.license_files.map { |f| [f.file_name, f.file_path] }.should =~ [
         %w[LICENSE vendor/LICENSE]
@@ -71,7 +73,7 @@ describe LicenseFinder::BundledGem do
     end
 
     it "includes both files nested inside LICENSE directory and top level files" do
-      stub(gemspec).full_gem_path { fixture_path('license_directory') }
+      gemspec.stub(:full_gem_path).and_return(fixture_path('license_directory'))
       found_license_files = subject.license_files
 
       found_license_files.map { |f| [f.file_name, f.file_path] }.should =~ [
@@ -91,7 +93,7 @@ describe LicenseFinder::BundledGem do
     end
 
     it "includes files with names like README, Readme or COPYING" do
-      stub(gemspec).full_gem_path { fixture_path('readme') }
+      gemspec.stub(:full_gem_path).and_return(fixture_path('readme'))
 
       subject.readme_files.map(&:file_name).should =~ [
         "Project ReadMe",
@@ -101,7 +103,7 @@ describe LicenseFinder::BundledGem do
     end
 
     it "includes files deep in the hierarchy" do
-      stub(gemspec).full_gem_path { fixture_path('nested_readme') }
+      gemspec.stub(:full_gem_path).and_return(fixture_path('nested_readme'))
 
       subject.readme_files.map { |f| [f.file_name, f.file_path] }.should =~ [
         %w[README vendor/README]
@@ -118,11 +120,12 @@ describe LicenseFinder::BundledGem do
     its(:source) { should == 'bundle' }
     its(:description) { should == 'description' }
     its(:homepage) { should == 'homepage' }
+    its(:children) { should == ['foo']}
 
     describe 'with a known license' do
       before do
-        stub(gemspec).full_gem_path { fixture_path('mit_licensed_gem') }
-        any_instance_of(LicenseFinder::PossibleLicenseFile, :license => 'Detected License')
+        gemspec.stub(:full_gem_path).and_return(fixture_path('mit_licensed_gem'))
+        LicenseFinder::PossibleLicenseFile.any_instance.stub(:license).and_return('Detected License')
       end
 
       its(:license) { should == 'Detected License' }
@@ -130,8 +133,8 @@ describe LicenseFinder::BundledGem do
 
     describe 'with an unknown license' do
       before do
-        stub(gemspec).full_gem_path { fixture_path('other_licensed_gem') }
-        any_instance_of(LicenseFinder::PossibleLicenseFile, :license => nil)
+        gemspec.stub(:full_gem_path).and_return(fixture_path('other_licensed_gem'))
+        LicenseFinder::PossibleLicenseFile.any_instance.stub(:license).and_return(nil)
       end
 
       its(:license) { should == 'other' }
@@ -139,7 +142,7 @@ describe LicenseFinder::BundledGem do
 
     describe 'with UTF8 file License' do
       before do
-        stub(gemspec).full_gem_path { fixture_path('utf8_gem') }
+        gemspec.stub(:full_gem_path).and_return(fixture_path('utf8_gem'))
       end
 
       it "handles non UTF8 encodings" do

data/spec/lib/license_finder/cli_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+module LicenseFinder
+  describe CLI do
+    describe "#execute!(options)" do
+      before { CLI.stub(:check_for_action_items) }
+
+      context "when the approve option is provided" do
+        it "should approve the requested gem" do
+          dependency = double('dependency', :name => nil)
+          dependency.should_receive(:approve!)
+
+          Dependency.stub(:find_by_name).with('foo').and_return(dependency)
+
+          CLI.execute! approve: true, dependency: 'foo'
+        end
+      end
+
+      context "when the -l (--license) switch is provided" do
+        it "should update the license on the requested gem" do
+          dependency = double :dependency, :name => nil
+          dependency.should_receive(:update_attributes).with(:license => "foo")
+
+          Dependency.stub(:find_by_name).with("foo_gem").and_return dependency
+
+          CLI.execute! license: "foo", dependency: 'foo_gem'
+        end
+      end
+
+      context "when no options are provided" do
+        it "should check for action items" do
+          CLI.should_receive(:check_for_action_items)
+          CLI.execute!
+        end
+      end
+    end
+  end
+end

data/spec/lib/license_finder/dependency_spec.rb

@@ -1,273 +1,180 @@
 require 'spec_helper'
 
-describe LicenseFinder::Dependency do
-  let(:attributes) do
-    {
-      'name' => "spec_name",
-      'version' => "2.1.3",
-      'license' => "GPLv2",
-      'approved' => false,
-      'notes' => 'some notes',
-      'homepage' => 'homepage',
-      'license_files' => [{'path' => '/Users/pivotal/foo/lic1'}, {'path' => '/Users/pivotal/bar/lic2'}],
-      'readme_files' => [{'path' => '/Users/pivotal/foo/Readme1'}, {'path' => '/Users/pivotal/bar/Readme2'}],
-      'source' => "bundle",
-      'bundler_groups' => nil
-    }
-  end
-
-  before do
-    stub(LicenseFinder).config.stub!.whitelist { %w(MIT) }
-  end
-
-  describe '.new' do
-    it "should mark it as approved when the license is whitelisted" do
-      dependency = LicenseFinder::Dependency.new(attributes.merge('license' => 'MIT', 'approved' => false))
-      dependency.approved.should == true
-    end
-
-    it "should not mark it as approved when the license is not whitelisted" do
-      dependency = LicenseFinder::Dependency.new(attributes.merge('license' => 'GPL', 'approved' => false))
-      dependency.approved.should == false
-    end
-
-    it "should leave it as approved when the license is not whitelisted but it has already been marked as approved" do
-      dependency = LicenseFinder::Dependency.new(attributes.merge('license' => 'GPL', 'approved' => true))
-      dependency.approved.should == true
-    end
-  end
-
-  describe '.from_hash' do
-    subject { LicenseFinder::Dependency.from_hash(attributes) }
-
-    its(:name) { should == 'spec_name' }
-    its(:version) { should == '2.1.3' }
-    its(:license) { should == 'GPLv2' }
-    its(:approved) { should == false }
-    its(:notes) { should == "some notes" }
-    its(:license_files) { should == %w(/Users/pivotal/foo/lic1 /Users/pivotal/bar/lic2) }
-    its(:readme_files) { should == %w(/Users/pivotal/foo/Readme1 /Users/pivotal/bar/Readme2) }
-    its(:source) { should == "bundle" }
-    its(:bundler_groups) { should == [] }
-
-    its(:as_yaml) do
-      should == {
-        'name' => 'spec_name',
-        'version' => '2.1.3',
-        'license' => 'GPLv2',
+module LicenseFinder
+  describe Dependency do
+    let(:attributes) do
+      {
+        'name' => "spec_name",
+        'version' => "2.1.3",
+        'license' => "GPLv2",
         'approved' => false,
-        'source' => 'bundle',
-        'homepage' => 'homepage',
-        'license_url' => LicenseFinder::License::GPLv2.license_url,
         'notes' => 'some notes',
-        'license_files' => [
-          {'path' => '/Users/pivotal/foo/lic1'},
-          {'path' => '/Users/pivotal/bar/lic2'}
-        ],
-        'readme_files' => [
-          {'path' => '/Users/pivotal/foo/Readme1'},
-          {'path' => '/Users/pivotal/bar/Readme2'}
-        ]
+        'homepage' => 'homepage',
+        'license_files' => ['/Users/pivotal/foo/lic1', '/Users/pivotal/bar/lic2'],
+        'readme_files' => ['/Users/pivotal/foo/Readme1', '/Users/pivotal/bar/Readme2'],
+        'source' => "bundle",
+        'bundler_groups' => ["test"]
       }
     end
 
-    it 'should generate yaml' do
-      yaml = YAML.load(subject.to_yaml)
-      yaml.should == subject.as_yaml
+    before do
+      LicenseFinder.stub(:config).and_return(double('config', {
+        :whitelist => %w(MIT),
+        :dependencies_yaml => 'dependencies.yml'
+      }))
     end
-  end
 
-  describe '#license_url' do
-    context "class exists for license type" do
-      it "should return the license url configured in the class" do
-        LicenseFinder::Dependency.new('license' => "GPLv2").license_url.should == LicenseFinder::License::GPLv2.license_url
+    describe "#approved" do
+      it "should return true when the license is whitelisted" do
+        dependency = Dependency.new('license' => 'MIT')
+        dependency.approved.should == true
       end
 
-      it "should handle differences in case" do
-        LicenseFinder::Dependency.new('license' => "gplv2").license_url.should == LicenseFinder::License::GPLv2.license_url
+      it "should return false when the license is not whitelisted" do
+        dependency = Dependency.new('license' => 'GPL')
+        dependency.approved.should == false
       end
-    end
 
-    context "class does not exist for license type" do
-      it "should return nil" do
-        LicenseFinder::Dependency.new('license' => "FakeLicense").license_url.should be_nil
+      it "should be overridable" do
+        dependency = Dependency.new
+        dependency.approved = true
+        dependency.approved.should == true
       end
     end
-  end
-
-  describe '#to_s' do
-    let(:gem) do
-      LicenseFinder::Dependency.new(
-        'name' => 'test_gem',
-        'version' => '1.0',
-        'summary' => 'summary foo',
-        'description' => 'description bar',
-        'license' => "MIT"
-      )
-    end
-
-    subject { gem.to_s.strip }
-
-    it 'should generate text with the gem name, version, and license' do
-      should == "test_gem, 1.0, MIT"
-    end
-  end
 
-  describe '#to_html' do
-    let(:dependency) { LicenseFinder::Dependency.new 'approved' => true }
-    subject { dependency.to_html }
-
-    context "when the dependency is approved" do
-      it "should add an approved class to dependency's container" do
-        should include %{class="approved"}
+    describe '#license_url' do
+      it "should delegate to LicenseUrl.find_by_name" do
+        LicenseFinder::LicenseUrl.stub(:find_by_name).with("MIT").and_return "http://license-url.com"
+        Dependency.new(:license => "MIT").license_url.should == "http://license-url.com"
       end
     end
 
-    context "when the dependency is not approved" do
-      before { dependency.approved = false }
-
-      it "should not add an approved class to he dependency's container" do
-        should include %{class="unapproved"}
+    describe '#merge' do
+      subject do
+        Dependency.new(
+          'name' => 'foo',
+          'license' => 'MIT',
+          'version' => '0.0.1',
+          'license_files' => "old license files",
+          'readme_files' => "old readme files"
+        )
       end
-    end
 
-    context "when the gem has at least one bundler group" do
-      before { dependency.bundler_groups = ["group"] }
-      it "should show the bundler group(s) in parens" do
-        should include "(group)"
+      let(:new_dep) do
+        Dependency.new(
+          'name' => 'foo',
+          'license' => 'MIT',
+          'version' => '0.0.2',
+          'license_files' => "new license files",
+          'readme_files' => "new readme files",
+          'summary' => 'foo summary',
+          'description' => 'awesome foo description!',
+          'bundler_groups' => [1, 2, 3],
+          'homepage' => "http://new.homepage"
+        )
       end
-    end
 
-    context "when the gem has no bundler groups" do
-      before { dependency.bundler_groups = [] }
+      it 'should raise an error if the names do not match' do
+        new_dep.name = 'bar'
 
-      it "should not show any parens or bundler group info" do
-        should_not include "()"
+        expect {
+          subject.merge(new_dep)
+        }.to raise_error
       end
 
-    end
-
-    context "when the gem has at least one parent" do
-      before { dependency.parents = [ OpenStruct.new(:name => "foo parent") ]}
-      it "should include a parents section" do
-        should include "Parents"
-      end
-    end
+      it 'should return the new version, license files, readme files, source, and homepage' do
+        merged = subject.merge(new_dep)
 
-    context "when the gem has no parents" do
-      it "should not include any parents section in the output" do
-        should_not include "Parents"
+        merged.version.should == '0.0.2'
+        merged.license_files.should == new_dep.license_files
+        merged.readme_files.should == new_dep.readme_files
+        merged.source.should == new_dep.source
+        merged.homepage.should == new_dep.homepage
       end
-    end
 
-    context "when the gem has at least one child" do
-      before { dependency.children = [ OpenStruct.new(:name => "foo child") ]}
+      it 'should return the new summary and description and bundle groups' do
+        merged = subject.merge new_dep
 
-      it "should include a Children section" do
-        should include "Children"
+        merged.summary.should == new_dep.summary
+        merged.description.should == new_dep.description
+        merged.bundler_groups.should == new_dep.bundler_groups
       end
-    end
 
-    context "when the gem has no children" do
-      it "should not include any Children section in the output" do
-        should_not include "Children"
-      end
-    end
-  end
+      it 'should return the old notes' do
+        subject.notes = 'old notes'
+        new_dep.notes = 'new notes'
 
-  describe '#source' do
-    it "should default to nil" do
-      LicenseFinder::Dependency.new.source.should be_nil
-    end
+        merged = subject.merge(new_dep)
 
-    it "should be overridable" do
-      LicenseFinder::Dependency.new("source" => "foo").source.should == "foo"
-    end
-  end
+        merged.notes.should == 'old notes'
+      end
 
-  describe '#merge' do
-    subject do
-      LicenseFinder::Dependency.new(
-        'name' => 'foo',
-        'license' => 'MIT',
-        'version' => '0.0.1',
-        'license_files' => "old license files",
-        'readme_files' => "old readme files",
-        'old_homepage' => "http://old.homepage"
-      )
-    end
+      context "license changes to something other than 'other'" do
+        before { new_dep.license = 'new license' }
 
-    let(:new_dep) do
-      LicenseFinder::Dependency.new(
-        'name' => 'foo',
-        'license' => 'MIT',
-        'version' => '0.0.2',
-        'license_files' => "new license files",
-        'readme_files' => "new readme files",
-        'summary' => 'foo summary',
-        'description' => 'awesome foo description!',
-        'bundler_groups' => [1,2,3],
-        'homepage' => "http://new.homepage"
-      )
-    end
+        context "new license is whitelisted" do
+          before { LicenseFinder.config.stub(:whitelist).and_return [new_dep.license] }
 
-    it 'should raise an error if the names do not match' do
-      new_dep.name = 'bar'
+          it "should set the approval to true" do
+            merged = subject.merge new_dep
+            merged.should be_approved
+          end
+        end
 
-      expect {
-        subject.merge(new_dep)
-      }.to raise_error
-    end
+        context "new license is not whitelisted" do
+          it "should set the approval to false" do
+            merged = subject.merge new_dep
+            merged.should_not be_approved
+          end
+        end
+      end
 
-    it 'should return the new version, license files, readme files, source, and homepage' do
-      merged = subject.merge(new_dep)
+      context "license changes to unknown (i.e., 'other')" do
+        before { new_dep.license = 'other' }
 
-      merged.version.should == '0.0.2'
-      merged.license_files.should == new_dep.license_files
-      merged.readme_files.should == new_dep.readme_files
-      merged.source.should == new_dep.source
-      merged.homepage.should == new_dep.homepage
-    end
-    
-    it 'should return the new summary and description and bundle groups' do
-      merged = subject.merge new_dep
-      
-      merged.summary.should     == new_dep.summary
-      merged.description.should == new_dep.description
-      merged.bundler_groups.should == new_dep.bundler_groups
-    end
+        it "should not change the license" do
+          merged = subject.merge new_dep
+          merged.license.should == 'MIT'
+        end
 
-    it 'should return the old notes' do
-      subject.notes = 'old notes'
-      new_dep.notes = 'new notes'
+        it "should not change the approval" do
+          approved = subject.approved?
+          merged = subject.merge new_dep
+          merged.approved?.should == approved
+        end
+      end
 
-      merged = subject.merge(new_dep)
+      context "license does not change" do
+        before { new_dep.license.should == subject.license }
 
-      merged.notes.should == 'old notes'
+        it "should not change the license or approval" do
+          existing_license = subject.license
+          existing_approval = subject.approved?
+          merged = subject.merge new_dep
+          merged.approved?.should == existing_approval
+          merged.license.should == existing_license
+        end
+      end
     end
 
-    it 'should return the new license and approval if the license is different' do
-      subject.license = "MIT"
-      subject.approved = true
-
-      new_dep.license = "GPLv2"
-      new_dep.approved = false
-
-      merged = subject.merge(new_dep)
-
-      merged.license.should == "GPLv2"
-      merged.approved.should == false
+    describe '#approve!' do
+      it "should update the yaml file to show the gem is approved" do
+        gem = Dependency.new(name: "foo")
+        gem.approve!
+        reloaded_gem = Dependency.find_by_name(gem.name)
+        reloaded_gem.approved.should be_true
+      end
     end
 
-    it 'should return the old license and approval if the new license is the same or "other"' do
-      subject.approved = false
-      new_dep.approved = true
-
-      subject.merge(new_dep).approved.should == false
-
-      new_dep.license = 'other'
-
-      subject.merge(new_dep).approved.should == false
+    describe "defaults" do
+      %w(license_files readme_files bundler_groups children parents).each do |attribute|
+        describe "##{attribute}" do
+          it "should default to an empty array" do
+            Dependency.new.send(attribute).should == []
+          end
+        end
+      end
     end
   end
 end
+