turbulence 1.2.4 → 1.3.0

data/lib/turbulence/generators/treemap.rb

@@ -4,8 +4,8 @@ class Turbulence
       attr_reader :metrics_hash, :x_metric, :y_metric
 
       def initialize(metrics_hash,
-                     x_metric = Turbulence::Calculators::Churn,
-                     y_metric = Turbulence::Calculators::Complexity)
+                     x_metric = :churn,
+                     y_metric = :complexity)
         @x_metric     = x_metric
         @y_metric     = y_metric
         @metrics_hash = metrics_hash

data/lib/turbulence/scm/git.rb

@@ -8,7 +8,7 @@ class Turbulence
 
         def is_repo?(directory)
           FileUtils.cd(directory) {
-            return !(`git status 2>&1` =~ /Not a git repository/)
+            return !(`git status 2>&1` =~ /not a git repository/i)
           }
         end
       end

data/lib/turbulence/version.rb

@@ -1,3 +1,3 @@
 class Turbulence
-  VERSION = "1.2.4"
+  VERSION = "1.3.0"
 end

data/lib/turbulence.rb

@@ -55,7 +55,7 @@ class Turbulence
 
     calculator.for_these_files(files_of_interest) do |filename, score|
       report "."
-      set_file_metric(filename, calculator.class, score)
+      set_file_metric(filename, calculator.type, score)
     end
 
     report "\n"

data/spec/turbulence/calculators/churn_spec.rb

@@ -5,150 +5,138 @@ describe Turbulence::Calculators::Churn do
   let(:config) { Turbulence::Configuration.new }
 
   before do
-    calculator.stub(:scm_log_command) { "" }
+    allow(calculator).to receive(:scm_log_command).and_return("")
   end
 
   describe "::for_these_files" do
     it "yields up the filename and score for each file" do
       files = ["lib/corey.rb", "lib/chad.rb"]
-      calculator.stub(:changes_by_ruby_file) {
-        [
-          ["lib/corey.rb", 5],
-          ["lib/chad.rb", 10]
-      ]
-      }
+      allow(calculator).to receive(:changes_by_ruby_file).and_return([
+        ["lib/corey.rb", 5],
+        ["lib/chad.rb", 10]
+      ])
       yielded_files = []
       calculator.for_these_files(files) do |filename, score|
         yielded_files << [filename, score]
       end
-      yielded_files.should =~ [["lib/corey.rb", 5],
-        ["lib/chad.rb",10]]
+      expect(yielded_files).to match_array([["lib/corey.rb", 5], ["lib/chad.rb", 10]])
     end
 
     it "filters the results by the passed-in files" do
       files = ["lib/corey.rb"]
-      calculator.stub(:changes_by_ruby_file) {
-        [
-          ["lib/corey.rb", 5],
-          ["lib/chad.rb", 10]
-      ]
-      }
+      allow(calculator).to receive(:changes_by_ruby_file).and_return([
+        ["lib/corey.rb", 5],
+        ["lib/chad.rb", 10]
+      ])
       yielded_files = []
       calculator.for_these_files(files) do |filename, score|
         yielded_files << [filename, score]
       end
-      yielded_files.should =~ [["lib/corey.rb", 5]]
+      expect(yielded_files).to match_array([["lib/corey.rb", 5]])
     end
   end
 
   describe "::scm_log_file_lines" do
     it "returns just the file lines" do
-      calculator.stub(:scm_log_command) do
-      "\n\n\n\n10\t6\tlib/turbulence.rb\n\n\n\n17\t2\tlib/eddies.rb\n"
-      end
+      allow(calculator).to receive(:scm_log_command).and_return(
+        "\n\n\n\n10\t6\tlib/turbulence.rb\n\n\n\n17\t2\tlib/eddies.rb\n"
+      )
 
-      calculator.scm_log_file_lines.should =~ [
+      expect(calculator.scm_log_file_lines).to match_array([
         "10\t6\tlib/turbulence.rb",
         "17\t2\tlib/eddies.rb"
-      ]
+      ])
     end
   end
 
   describe "::counted_line_changes_by_file_by_commit" do
     before do
-      calculator.stub(:scm_log_file_lines) {
-        [
-          "10\t6\tlib/turbulence.rb",
-          "17\t2\tlib/eddies.rb"
-        ]
-      }
+      allow(calculator).to receive(:scm_log_file_lines).and_return([
+        "10\t6\tlib/turbulence.rb",
+        "17\t2\tlib/eddies.rb"
+      ])
     end
 
     it "sums up the line changes" do
-      calculator.counted_line_changes_by_file_by_commit.should =~ [["lib/turbulence.rb", 16], ["lib/eddies.rb", 19]]
+      expect(calculator.counted_line_changes_by_file_by_commit).to match_array([["lib/turbulence.rb", 16], ["lib/eddies.rb", 19]])
     end
   end
-  
+
   describe "::changes_by_ruby_file" do
     before do
-      calculator.stub(:ruby_files_changed_in_scm) {
-        [
-          ['lib/eddies.rb', 4],
-          ['lib/turbulence.rb', 5],
-          ['lib/turbulence.rb', 16],
-          ['lib/eddies.rb', 2],
-          ['lib/turbulence.rb', 7],
-          ['lib/eddies.rb', 19],
-          ['lib/eddies.rb', 28]
-        ]
-      }
+      allow(calculator).to receive(:ruby_files_changed_in_scm).and_return([
+        ['lib/eddies.rb', 4],
+        ['lib/turbulence.rb', 5],
+        ['lib/turbulence.rb', 16],
+        ['lib/eddies.rb', 2],
+        ['lib/turbulence.rb', 7],
+        ['lib/eddies.rb', 19],
+        ['lib/eddies.rb', 28]
+      ])
     end
-    
+
     it "groups and sums churns, excluding the last" do
       calculator.compute_mean = false
-      calculator.changes_by_ruby_file.should =~ [ ['lib/eddies.rb', 25], ['lib/turbulence.rb', 21]]
+      expect(calculator.changes_by_ruby_file).to match_array([['lib/eddies.rb', 25], ['lib/turbulence.rb', 21]])
     end
 
     it "interprets a single entry as zero churn" do
-      calculator.stub(:ruby_files_changed_in_scm) {
-        [
-          ['lib/eddies.rb', 4],
-        ]
-      }
+      allow(calculator).to receive(:ruby_files_changed_in_scm).and_return([
+        ['lib/eddies.rb', 4],
+      ])
       calculator.compute_mean = false
-      calculator.changes_by_ruby_file.should =~ [ ['lib/eddies.rb', 0] ]
+      expect(calculator.changes_by_ruby_file).to match_array([['lib/eddies.rb', 0]])
     end
-    
+
     it "groups and takes the mean of churns, excluding the last" do
       calculator.compute_mean = true
-      calculator.changes_by_ruby_file.should =~ [ ['lib/eddies.rb', 8], ['lib/turbulence.rb', 10]]
+      expect(calculator.changes_by_ruby_file).to match_array([['lib/eddies.rb', 8], ['lib/turbulence.rb', 10]])
       calculator.compute_mean = false
     end
   end
 
   describe "::calculate_mean_of_churn" do
     it "handles zero sample size" do
-      calculator.calculate_mean_of_churn(8,0).should == 8
+      expect(calculator.calculate_mean_of_churn(8, 0)).to eq 8
     end
 
-    it "returns original churn for sample size = 1"  do
-      calculator.calculate_mean_of_churn(8,1).should == 8
+    it "returns original churn for sample size = 1" do
+      expect(calculator.calculate_mean_of_churn(8, 1)).to eq 8
     end
 
     it "returns churn divided by sample size" do
-      calculator.calculate_mean_of_churn(25,3).should == 8
+      expect(calculator.calculate_mean_of_churn(25, 3)).to eq 8
     end
-
   end
 
   context "Full stack tests" do
     context "when one ruby file is given" do
       context "with two log entries for file" do
         before do
-          calculator.stub(:scm_log_command) do
+          allow(calculator).to receive(:scm_log_command).and_return(
             "\n\n\n\n10\t6\tlib/turbulence.rb\n" +
-              "\n\n\n\n11\t7\tlib/turbulence.rb\n"
-          end
+            "\n\n\n\n11\t7\tlib/turbulence.rb\n"
+          )
         end
         it "gives the line change count for the file" do
           yielded_files = []
           calculator.for_these_files(["lib/turbulence.rb"]) do |filename, score|
             yielded_files << [filename, score]
           end
-          yielded_files.should =~ [["lib/turbulence.rb", 16]]
+          expect(yielded_files).to match_array([["lib/turbulence.rb", 16]])
         end
         context "with only one log entry for file" do
           before do
-            calculator.stub(:scm_log_command) do
+            allow(calculator).to receive(:scm_log_command).and_return(
               "\n\n\n\n10\t6\tlib/turbulence.rb\n"
-            end
+            )
           end
           it "shows zero churn for the file" do
             yielded_files = []
             calculator.for_these_files(["lib/turbulence.rb"]) do |filename, score|
               yielded_files << [filename, score]
             end
-            yielded_files.should =~ [["lib/turbulence.rb", 0]]
+            expect(yielded_files).to match_array([["lib/turbulence.rb", 0]])
           end
         end
       end

data/spec/turbulence/calculators/complexity_spec.rb

@@ -7,15 +7,12 @@ describe Turbulence::Calculators::Complexity do
   describe "::for_these_files" do
     it "yields up the filename and score for each file" do
       files = ["lib/corey.rb", "lib/chad.rb"]
-      calculator.stub(:score_for_file) { |filename|
-        filename.size
-      }
+      allow(calculator).to receive(:score_for_file) { |filename| filename.size }
       yielded_files = []
       calculator.for_these_files(files) do |filename, score|
         yielded_files << [filename, score]
       end
-      yielded_files.should =~ [["lib/corey.rb", 12],
-        ["lib/chad.rb",11]]
+      expect(yielded_files).to match_array([["lib/corey.rb", 12], ["lib/chad.rb", 11]])
     end
   end
 end

data/spec/turbulence/cli_parser_spec.rb

@@ -10,31 +10,41 @@ describe Turbulence::CommandLineInterface::ConfigParser do
 
   it "sets directory" do
     parse %w( path/to/compute )
-    config.directory.should == 'path/to/compute'
+    expect(config.directory).to eq 'path/to/compute'
   end
 
   it "sets SCM name to 'Perforce'" do
     parse %w( --scm p4 )
-    config.scm_name.should == 'Perforce'
+    expect(config.scm_name).to eq 'Perforce'
   end
 
   it "sets commit range" do
     parse %w( --churn-range f3e1d7a6..830b9d3d9f )
-    config.commit_range.should eq('f3e1d7a6..830b9d3d9f')
+    expect(config.commit_range).to eq 'f3e1d7a6..830b9d3d9f'
   end
 
   it "sets compute mean" do
     parse %w( --churn-mean )
-    config.compute_mean.should be_true
+    expect(config.compute_mean).to be true
   end
 
   it "sets the exclusion pattern" do
     parse %w( --exclude turbulence )
-    config.exclusion_pattern.should == 'turbulence'
+    expect(config.exclusion_pattern).to eq 'turbulence'
   end
 
   it "sets the graph type" do
     parse %w( --treemap )
-    config.graph_type.should == 'treemap'
+    expect(config.graph_type).to eq 'treemap'
+  end
+
+  it "sets no_open" do
+    parse %w( --no-open )
+    expect(config.no_open).to be true
+  end
+
+  it "sets output_dir" do
+    parse %w( --output spec/reports/turbulence )
+    expect(config.output_dir).to eq 'spec/reports/turbulence'
   end
 end

data/spec/turbulence/command_line_interface_spec.rb

@@ -6,7 +6,9 @@ describe Turbulence::CommandLineInterface do
 
   describe "::TEMPLATE_FILES" do
     Turbulence::CommandLineInterface::TEMPLATE_FILES.each do |template_file|
-      File.dirname(template_file).should == Turbulence::CommandLineInterface::TURBULENCE_TEMPLATE_PATH
+      it "has #{File.basename(template_file)} in the template path" do
+        expect(File.dirname(template_file)).to eq Turbulence::CommandLineInterface::TURBULENCE_TEMPLATE_PATH
+      end
     end
   end
 
@@ -16,18 +18,48 @@ describe Turbulence::CommandLineInterface do
     end
     it "bundles the files" do
       cli.generate_bundle
-      Dir.glob('turbulence/*').sort.should eq(["turbulence/cc.js",
-                                               "turbulence/highcharts.js",
-                                               "turbulence/jquery.min.js",
-                                               "turbulence/treemap.html",
-                                               "turbulence/turbulence.html"])
+      expect(Dir.glob('turbulence/*').sort).to eq(["turbulence/cc.js",
+                                                   "turbulence/highcharts.js",
+                                                   "turbulence/jquery.min.js",
+                                                   "turbulence/treemap.html",
+                                                   "turbulence/turbulence.html"])
     end
 
     it "passes along exclusion pattern" do
       cli = Turbulence::CommandLineInterface.new(%w(--exclude turbulence), :output => nil)
       cli.generate_bundle
       lines = File.new('turbulence/cc.js').readlines
-      lines.any? { |l| l =~ /turbulence\.rb/ }.should be_false
+      expect(lines.any? { |l| l =~ /turbulence\.rb/ }).to be false
+    end
+
+    it "outputs to custom directory when --output is specified" do
+      custom_dir = 'tmp/custom_output'
+      FileUtils.remove_dir(custom_dir, true)
+      cli = Turbulence::CommandLineInterface.new(['--output', custom_dir], :output => nil)
+      cli.generate_bundle
+      expect(Dir.glob("#{custom_dir}/*").sort).to eq(["#{custom_dir}/cc.js",
+                                                       "#{custom_dir}/highcharts.js",
+                                                       "#{custom_dir}/jquery.min.js",
+                                                       "#{custom_dir}/treemap.html",
+                                                       "#{custom_dir}/turbulence.html"])
+      FileUtils.remove_dir(custom_dir, true)
+    end
+  end
+
+  describe "#output_path" do
+    before do
+      # Reset the singleton config between tests
+      Turbulence.instance_variable_set(:@config, nil)
+    end
+
+    it "defaults to ./turbulence when output_dir is not set" do
+      cli = Turbulence::CommandLineInterface.new(%w(.), :output => nil)
+      expect(cli.output_path).to eq(File.join(Dir.pwd, "turbulence"))
+    end
+
+    it "returns the custom output_dir when set" do
+      cli = Turbulence::CommandLineInterface.new(%w(--output custom/path), :output => nil)
+      expect(cli.output_path).to eq('custom/path')
     end
   end
 end

data/spec/turbulence/configuration_spec.rb

@@ -1,13 +1,19 @@
 require 'rspec'
+require 'rspec/its'
 require 'turbulence'
 
 describe Turbulence::Configuration do
   describe "defaults" do
-    its(:output)     { should eq(STDOUT) }
-    its(:directory)  { should eq(Dir.pwd) }
-    its(:graph_type) { should eq('turbulence') }
-    its(:scm_name)   { should eq('Git') }
-    its(:scm)        { should eq(Turbulence::Scm::Git) }
+    its(:output)            { should eq(STDOUT) }
+    its(:directory)         { should eq(Dir.pwd) }
+    its(:graph_type)        { should eq('turbulence') }
+    its(:scm_name)          { should eq('Git') }
+    its(:scm)               { should eq(Turbulence::Scm::Git) }
+    its(:no_open)           { should eq(false) }
+    its(:output_dir)        { should be_nil }
+    its(:commit_range)      { should be_nil }
+    its(:compute_mean)      { should be_nil }
+    its(:exclusion_pattern) { should be_nil }
   end
 end
 

data/spec/turbulence/generators/scatter_plot_spec.rb

@@ -2,93 +2,98 @@ require 'turbulence'
 
 describe Turbulence::Generators::ScatterPlot do
   context "with both Metrics" do
-    it "generates JavaScript" do
+    it "generates JavaScript", :aggregate_failures do
       generator = Turbulence::Generators::ScatterPlot.new(
-        "foo.rb" => { Turbulence::Calculators::Churn      => 1,
-                      Turbulence::Calculators::Complexity => 2 }
+        "foo.rb" => { :churn      => 1,
+                      :complexity => 2 }
       )
 
-      generator.to_js.should =~ /var directorySeries/
-      generator.to_js.should =~ /\"filename\"\:\"foo.rb\"/
-      generator.to_js.should =~ /\"x\":1/
-      generator.to_js.should =~ /\"y\":2/
+      expect(generator.to_js).to match(/var directorySeries/)
+      expect(generator.to_js).to match(/\"filename\"\:\"foo.rb\"/)
+      expect(generator.to_js).to match(/\"x\":1/)
+      expect(generator.to_js).to match(/\"y\":2/)
     end
   end
 
   context "with a missing Metric" do
     it "generates JavaScript" do
       generator = Turbulence::Generators::ScatterPlot.new(
-        "foo.rb" => { Turbulence::Calculators::Churn => 1 }
+        "foo.rb" => { :churn => 1 }
       )
 
-      generator.to_js.should == 'var directorySeries = {};'
+      expect(generator.to_js).to eq 'var directorySeries = {};'
     end
   end
 
   describe "#clean_metrics_from_missing_data" do
-    let(:spg) {Turbulence::Generators::ScatterPlot.new({})}
+    let(:spg) { Turbulence::Generators::ScatterPlot.new({}) }
 
     it "removes entries with missing churn" do
-      spg.stub(:metrics_hash).and_return("foo.rb" => {
-        Turbulence::Calculators::Complexity => 88.3})
-        spg.clean_metrics_from_missing_data.should == {}
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => { :complexity => 88.3 })
+      expect(spg.clean_metrics_from_missing_data).to eq({})
     end
 
     it "removes entries with missing complexity" do
-      spg.stub(:metrics_hash).and_return("foo.rb" => {
-        Turbulence::Calculators::Churn => 1})
-        spg.clean_metrics_from_missing_data.should == {}
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => { :churn => 1 })
+      expect(spg.clean_metrics_from_missing_data).to eq({})
     end
 
     it "keeps entries with churn and complexity present" do
-      spg.stub(:metrics_hash).and_return("foo.rb" => {
-        Turbulence::Calculators::Churn => 1,
-        Turbulence::Calculators::Complexity => 88.3})
-        spg.clean_metrics_from_missing_data.should_not == {}
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => {
+        :churn      => 1,
+        :complexity => 88.3,
+      })
+
+      expect(spg.clean_metrics_from_missing_data).not_to eq({})
     end
   end
 
   describe "#grouped_by_directory" do
-    let(:spg) {Turbulence::Generators::ScatterPlot.new("lib/foo/foo.rb" => {
-      Turbulence::Calculators::Churn => 1},
-      "lib/bar.rb" => {
-      Turbulence::Calculators::Churn => 2} )}
-
-      it "uses \".\" to denote flat hierarchy" do
-        spg.stub(:metrics_hash).and_return("foo.rb" => {
-          Turbulence::Calculators::Churn => 1
-        })
-        spg.grouped_by_directory.should == {"." => [["foo.rb", {Turbulence::Calculators::Churn => 1}]]}
-      end
-
-      it "takes full path into account" do
-        spg.grouped_by_directory.should == {"lib/foo" => [["lib/foo/foo.rb", {Turbulence::Calculators::Churn => 1}]],
-          "lib" => [["lib/bar.rb", {Turbulence::Calculators::Churn => 2}]]}
-      end
+    let(:spg) {
+      Turbulence::Generators::ScatterPlot.new(
+        "lib/foo/foo.rb" => { :churn => 1 },
+        "lib/bar.rb" => { :churn => 2 }
+      )
+    }
+
+    it "uses \".\" to denote flat hierarchy" do
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => { :churn => 1 })
+      expect(spg.grouped_by_directory).to eq({ "." => [["foo.rb", { :churn => 1 }]] })
+    end
+
+    it "takes full path into account" do
+      expect(spg.grouped_by_directory).to eq({
+        "lib/foo" => [["lib/foo/foo.rb", { :churn => 1 }]],
+        "lib" => [["lib/bar.rb", { :churn => 2 }]]
+      })
+    end
   end
 
   describe "#file_metrics_for_directory" do
-    let(:spg) {Turbulence::Generators::ScatterPlot.new({})}
+    let(:spg) { Turbulence::Generators::ScatterPlot.new({}) }
+
     it "assigns :filename, :x, :y" do
-      spg.file_metrics_for_directory("lib/foo/foo.rb" => {
-        Turbulence::Calculators::Churn => 1,
-        Turbulence::Calculators::Complexity => 88.2}).should == [{:filename => "lib/foo/foo.rb",
-        :x => 1, :y => 88.2}]
+      result = spg.file_metrics_for_directory("lib/foo/foo.rb" => {
+        :churn      => 1,
+        :complexity => 88.2,
+      })
+      expect(result).to eq [{ :filename => "lib/foo/foo.rb", :x => 1, :y => 88.2 }]
     end
   end
 
   describe Turbulence::FileNameMangler do
     subject { Turbulence::FileNameMangler.new }
+
     it "anonymizes a string" do
-      subject.mangle_name("chad").should_not == "chad"
+      expect(subject.mangle_name("chad")).not_to eq "chad"
     end
 
     it "maintains standard directory names" do
-      subject.mangle_name("/app/controllers/chad.rb").should =~ %r{/app/controllers/1.rb}
+      expect(subject.mangle_name("/app/controllers/chad.rb")).to match(%r{/app/controllers/1.rb})
     end
 
     it "honors leading path separators" do
-      subject.mangle_name("/a/b/c.rb").should == "/1/2/3.rb"
+      expect(subject.mangle_name("/a/b/c.rb")).to eq "/1/2/3.rb"
     end
   end
 end

data/spec/turbulence/generators/treemap_spec.rb

@@ -2,24 +2,24 @@ require 'turbulence'
 
 describe Turbulence::Generators::TreeMap do
   context "with both Metrics" do
-    it "generates JavaScript" do
+    it "generates JavaScript", :aggregate_failures do
       generator = Turbulence::Generators::TreeMap.new(
-        "foo.rb" => { Turbulence::Calculators::Churn      => 1,
-                      Turbulence::Calculators::Complexity => 2 }
+        "foo.rb" => { :churn      => 1,
+                      :complexity => 2 }
       )
 
-      generator.build_js.should =~ /var treemap_data/
-      generator.build_js.should =~ /\'foo.rb\'/
+      expect(generator.build_js).to match(/var treemap_data/)
+      expect(generator.build_js).to match(/\'foo.rb\'/)
     end
   end
 
   context "with a missing Metric" do
     it "generates JavaScript" do
       generator = Turbulence::Generators::TreeMap.new(
-        "foo.rb" => { Turbulence::Calculators::Churn => 1 }
+        "foo.rb" => { :churn => 1 }
       )
 
-      generator.build_js.should == "var treemap_data = [['File', 'Parent', 'Churn (size)', 'Complexity (color)'],\n['Root', null, 0, 0],\n];"
+      expect(generator.build_js).to eq "var treemap_data = [['File', 'Parent', 'Churn (size)', 'Complexity (color)'],\n['Root', null, 0, 0],\n];"
     end
   end
 end

data/spec/turbulence/scm/git_spec.rb

@@ -5,25 +5,26 @@ require 'fileutils'
 describe Turbulence::Scm::Git do
   describe "::is_repo?" do
     before do
-      @tmp = Dir.mktmpdir(nil,'..')
+      # Create temp dir in system temp location (outside any git repo)
+      @tmp = Dir.mktmpdir('turbulence-test')
     end
     after do
-      FileUtils.rmdir(@tmp)
+      FileUtils.remove_entry(@tmp)
     end
     it "returns true for the working directory" do
-      Turbulence::Scm::Git.is_repo?(".").should == true
+      expect(Turbulence::Scm::Git.is_repo?(".")).to eq true
     end
     it "return false for a newly created tmp directory" do
-      Turbulence::Scm::Git.is_repo?(@tmp).should == false
+      expect(Turbulence::Scm::Git.is_repo?(@tmp)).to eq false
     end
   end
 
   describe "::log_command" do
     it "takes an optional argument specify to the range" do
-      expect{Turbulence::Scm::Git.log_command("d551e63f79a90430e560ea871f4e1e39e6e739bd  HEAD")}.to_not raise_error
+      expect { Turbulence::Scm::Git.log_command("d551e63f79a90430e560ea871f4e1e39e6e739bd  HEAD") }.to_not raise_error
     end
     it "lists insertions/deletions per file and change" do
-      Turbulence::Scm::Git.log_command.should match(/\d+\t\d+\t[A-z.]*/)
+      expect(Turbulence::Scm::Git.log_command).to match(/\d+\t\d+\t[A-z.]*/)
     end
   end
 end