rainforest-cli 1.2.0 → 1.2.1

data/lib/rainforest/cli/test_parser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module RainforestCli::TestParser
   class EmbeddedTest < Struct.new(:rfml_id)
     def type
@@ -7,6 +8,16 @@ module RainforestCli::TestParser
     def to_s
       "--> embed: #{rfml_id}"
     end
+
+    def to_element(primary_key_id)
+      {
+        type: 'test',
+        redirection: true,
+        element: {
+          id: primary_key_id
+        }
+      }
+    end
   end
 
   class Step < Struct.new(:action, :response)
@@ -17,28 +28,40 @@ module RainforestCli::TestParser
     def to_s
       "#{action} --> #{response}"
     end
-  end
 
-  class Error < Struct.new(:line, :reason)
-    def to_s
-      "Line #{line}: #{reason}"
+    def to_element
+      {
+        type: 'step',
+        redirection: true,
+        element: {
+          action: action,
+          response: response
+        }
+      }
     end
   end
 
-  class Test < Struct.new(:rfml_id, :description, :title, :start_uri, :steps, :errors, :tags, :browsers)
+  class Test < Struct.new(:file_name, :rfml_id, :description, :title, :start_uri, :steps, :errors, :tags, :browsers)
     def embedded_ids
       steps.inject([]) { |embeds, step| step.type == :test ? embeds + [step.rfml_id] : embeds }
     end
   end
 
+  class Error < Struct.new(:line, :reason)
+    def to_s
+      "Line #{line}: #{reason}"
+    end
+  end
+
   class Parser
     attr_reader :steps, :errors, :text
 
-    def initialize(text)
-      @text = text.to_s
+    def initialize(file_name)
+      @text = File.read(file_name).to_s
 
       @test = Test.new
-      @test.description = ""
+      @test.file_name = file_name
+      @test.description = ''
       @test.steps = []
       @test.errors = {}
       @test.tags = []
@@ -51,10 +74,11 @@ module RainforestCli::TestParser
     def process
       scratch = []
 
-      text.lines.map(&:chomp).each_with_index do |line, line_no|
+      text.lines.each_with_index do |line, line_no|
+        line = line.chomp
         if line[0..1] == '#!'
           # special comment, don't ignore!
-          @test.rfml_id = line[2..-1].strip.split(" ")[0]
+          @test.rfml_id = line[2..-1].strip.split(' ')[0]
           @test.description += line[1..-1] + "\n"
 
         elsif line[0] == '#'
@@ -65,7 +89,7 @@ module RainforestCli::TestParser
             next unless line[1..-1].strip[0..(field.length)] == "#{field}:"
 
             # extract just the text of the field
-            @test[field] = line[1..-1].split(" ")[1..-1].join(" ").strip
+            @test[field] = line[1..-1].split(' ')[1..-1].join(' ').strip
 
             # if it's supposed to be a CSV field, split and trim it
             if CSV_FIELDS.include?(field)
@@ -82,9 +106,9 @@ module RainforestCli::TestParser
 
         elsif scratch.count == 1
           if line.strip == ''
-            @test.errors[line_no] = Error.new(line_no, "Missing question")
+            @test.errors[line_no] = Error.new(line_no, 'Missing question')
           elsif !line.include?('?')
-            @test.errors[line_no] = Error.new(line_no, "Missing ?")
+            @test.errors[line_no] = Error.new(line_no, 'Missing ?')
           else
             scratch << line.strip
           end
@@ -102,7 +126,7 @@ module RainforestCli::TestParser
       end
 
       if @test.rfml_id == nil
-        @test.errors[0] = Error.new(0, "Missing RFML ID. Please start a line #! followed by a unique id.")
+        @test.errors[0] = Error.new(0, 'Missing RFML ID. Please start a line #! followed by a unique id.')
       end
 
       return @test

data/lib/rainforest/cli/uploader.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+require 'rainforest'
+require 'parallel'
+require 'ruby-progressbar'
+
+class RainforestCli::Uploader
+  attr_reader :test_files, :remote_tests, :validator
+
+  def initialize(options)
+    @test_files = RainforestCli::TestFiles.new(options.test_folder)
+    @remote_tests = RainforestCli::RemoteTests.new(options.token)
+    @validator = RainforestCli::Validator.new(options, test_files, remote_tests)
+  end
+
+  def upload
+    validator.validate_with_exception!
+
+    # Create new tests first to ensure that they can be embedded
+    if new_tests.any?
+      logger.info 'Syncing new tests...'
+      each_in_parallel(new_tests) { |rfml_test| upload_empty_test(rfml_test) }
+    end
+
+    # Update all tests
+    logger.info 'Uploading tests...'
+    each_in_parallel(rfml_tests) { |rfml_test| upload_test(rfml_test) }
+  end
+
+  private
+
+  def each_in_parallel(tests, &blk)
+    progress_bar = ProgressBar.create(title: 'Rows', total: tests.count, format: '%a %B %p%% %t')
+    Parallel.each(tests, in_threads: threads, finish: lambda { |_item, _i, _result| progress_bar.increment }) do |rfml_test|
+      blk.call(rfml_test)
+    end
+  end
+
+  def rfml_tests
+    @rfml_tests ||= test_files.test_data
+  end
+
+  def new_tests
+    @new_tests ||= rfml_tests.select { |t| primary_key_dictionary[t.rfml_id].nil? }
+  end
+
+  def primary_key_dictionary
+    @primary_key_dictionary ||= remote_tests.primary_key_dictionary
+  end
+
+  def upload_empty_test(rfml_test)
+    test_obj = {
+      title: rfml_test.title,
+      start_uri: rfml_test.start_uri,
+      rfml_id: rfml_test.rfml_id
+    }
+    rf_test = Rainforest::Test.create(test_obj)
+
+    primary_key_dictionary[rfml_test.rfml_id] = rf_test.id
+  end
+
+  def upload_test(rfml_test)
+    return unless rfml_test.steps.count > 0
+
+    test_obj = create_test_obj(rfml_test)
+    begin
+      Rainforest::Test.update(primary_key_dictionary[rfml_test.rfml_id], test_obj)
+    rescue => e
+      logger.fatal "Error: #{rfml_test.rfml_id}: #{e}"
+      exit 2
+    end
+  end
+
+  def threads
+    RainforestCli::THREADS
+  end
+
+  def logger
+    RainforestCli.logger
+  end
+
+  def create_test_obj(rfml_test)
+    test_obj = {
+      start_uri: rfml_test.start_uri || '/',
+      title: rfml_test.title,
+      description: rfml_test.description,
+      source: 'rainforest-cli',
+      tags: rfml_test.tags.uniq,
+      rfml_id: rfml_test.rfml_id
+    }
+
+    test_obj[:elements] = rfml_test.steps.map do |step|
+      if step.respond_to?(:rfml_id)
+        step.to_element(primary_key_dictionary[step.rfml_id])
+      else
+        step.to_element
+      end
+    end
+
+    unless rfml_test.browsers.empty?
+      test_obj[:browsers] = rfml_test.browsers.map do|b|
+        {'state' => 'enabled', 'name' => b}
+      end
+    end
+
+    test_obj
+  end
+end

data/lib/rainforest/cli/validator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+class RainforestCli::Validator
+  API_TOKEN_ERROR = 'Please supply API token and try again'
+  VALIDATIONS_PASSED = '[VALID]'
+  VALIDATIONS_FAILED = '[INVALID] - Please see log to correct errors.'
+
+  attr_reader :local_tests, :remote_tests
+
+  def initialize(options, local_tests = nil, remote_tests = nil)
+    @local_tests = local_tests || RainforestCli::TestFiles.new(options.test_folder)
+    @remote_tests = remote_tests || RainforestCli::RemoteTests.new(options.token)
+  end
+
+  def validate
+    check_test_directory_for_tests!
+    invalid?
+  end
+
+  def validate_with_exception!
+    check_test_directory_for_tests!
+
+    unless remote_tests.api_token_set?
+      logger.error API_TOKEN_ERROR
+      exit 2
+    end
+
+    exit 1 if invalid?
+  end
+
+  def invalid?
+    # Assign result to variables to ensure both methods are called
+    # (no short-circuiting with ||)
+    parsing_errors = has_parsing_errors?
+    dependency_errors = has_test_dependency_errors?
+    is_invalid = parsing_errors || dependency_errors
+
+    logger.info ''
+    logger.info(is_invalid ? VALIDATIONS_FAILED : VALIDATIONS_PASSED)
+    is_invalid
+  end
+
+  private
+
+  def check_test_directory_for_tests!
+    unless local_tests.count > 0
+      logger.error "No tests found in directory: #{local_tests.test_folder}"
+      exit 3
+    end
+  end
+
+  def has_parsing_errors?
+    logger.info 'Validating parsing errors...'
+    has_parsing_errors = rfml_tests.select { |t| t.errors.any? }
+
+    return false unless has_parsing_errors.any?
+
+    parsing_error_notification(has_parsing_errors)
+    true
+  end
+
+  def has_test_dependency_errors?
+    logger.info 'Validating embedded test IDs...'
+
+    # Assign result to variables to ensure both methods are called
+    nonexisting_tests = has_nonexisting_tests?
+    circular_dependencies = has_circular_dependencies?
+    nonexisting_tests || circular_dependencies
+  end
+
+  def has_nonexisting_tests?
+    contains_nonexistent_ids = rfml_tests.select { |t| (t.embedded_ids - all_rfml_ids).any? }
+
+    return false unless contains_nonexistent_ids.any?
+
+    nonexisting_embedded_id_notification(contains_nonexistent_ids)
+    true
+  end
+
+  def has_circular_dependencies?
+    # TODO: Check embedded tests for remote tests as well. The Rainforest Ruby client
+    # doesn't appear to support elements yet.
+    has_circular_dependencies = false
+    rfml_tests.each do |rfml_test|
+      has_circular_dependencies ||= check_for_nested_embed(rfml_test, rfml_test.rfml_id, rfml_test.file_name)
+    end
+    has_circular_dependencies
+  end
+
+  def check_for_nested_embed(rfml_test, root_id, root_file)
+    rfml_test.embedded_ids.each do |embed_id|
+      descendant = test_dictionary[embed_id]
+
+      # existence for embedded tests is covered in #has_nonexisting_tests?
+      next unless descendant
+
+      if descendant.embedded_ids.include?(root_id)
+        circular_dependencies_notification(root_file, descendant.file_name) if descendant.embedded_ids.include?(root_id)
+        return true
+      end
+
+      check_for_nested_embed(descendant, root_id, root_file)
+    end
+    false
+  end
+
+  def rfml_tests
+    @rfml_tests ||= local_tests.test_data
+  end
+
+  def all_rfml_ids
+    local_rfml_ids + remote_rfml_ids
+  end
+
+  def local_rfml_ids
+    @local_rfml_ids ||= local_tests.rfml_ids
+  end
+
+  def remote_rfml_ids
+    @remote_rfml_ids ||= remote_tests.rfml_ids
+  end
+
+  def test_dictionary
+    @test_dictionary ||= local_tests.test_dictionary
+  end
+
+  def parsing_error_notification(rfml_tests)
+    logger.error 'Parsing errors:'
+    logger.error ''
+    rfml_tests.each do |rfml_test|
+      logger.error "\t#{rfml_test.file_name}"
+      rfml_test.errors.each do |_line, error|
+        logger.error "\t#{error}"
+      end
+    end
+    logger.error ''
+  end
+
+  def nonexisting_embedded_id_notification(rfml_tests)
+    logger.error 'The following files contain unknown embedded test IDs:'
+    logger.error ''
+    rfml_tests.each do |rfml_test|
+      logger.error "\t#{rfml_test.file_name}"
+    end
+    logger.error ''
+  end
+
+  def circular_dependencies_notification(file_a, file_b)
+    logger.error 'The following files are embedding one another:'
+    logger.error ''
+    logger.error "\t#{file_a}"
+    logger.error "\t#{file_b}"
+    logger.error ''
+  end
+
+  def logger
+    RainforestCli.logger
+  end
+end

data/lib/rainforest/cli/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module RainforestCli
-  VERSION = "1.2.0"
+  VERSION = '1.2.1'
 end

data/rainforest-cli.gemspec

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rainforest/cli/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "rainforest-cli"
+  spec.name          = 'rainforest-cli'
   spec.version       = RainforestCli::VERSION
-  spec.authors       = ["Simon Mathieu", "Russell Smith"]
-  spec.email         = ["simon@rainforestqa.com", "russ@rainforestqa.com"]
+  spec.authors       = ['Russell Smith', 'Edward Paulet']
+  spec.email         = ['russ@rainforestqa.com', 'edward@rainforestqa.com']
   spec.description   = %q{Command line utility for Rainforest QA}
   spec.summary       = %q{Command line utility for Rainforest QA}
-  spec.homepage      = "https://www.rainforestqa.com/"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://www.rainforestqa.com/'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "httparty"
-  spec.add_dependency "parallel"
-  spec.add_dependency "ruby-progressbar"
-  spec.add_dependency "rainforest"
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_dependency 'httparty', '~> 0.13.7'
+  spec.add_dependency 'parallel', '~> 1.6', '>= 1.6.1'
+  spec.add_dependency 'ruby-progressbar', '~> 1.7', '>= 1.7.5'
+  spec.add_dependency 'rainforest', '~> 2.1', '>= 2.1.0'
+  spec.add_dependency 'http-exceptions', '~> 0.0', '>= 0.0.4'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake', '~> 10.4', '>= 10.4.2'
 end

data/spec/cli_spec.rb

@@ -1,45 +1,46 @@
+# frozen_string_literal: true
 describe RainforestCli do
-  let(:http_client) { RainforestCli::HttpClient.any_instance }
+  let(:http_client) { RainforestCli::HttpClient }
 
   before do
-    Kernel.stub(:sleep)
+    allow(Kernel).to receive(:sleep)
   end
 
-  describe ".start" do
+  describe '.start' do
     let(:valid_args) { %w(run --token foo run --fg all) }
     let(:ok_progress) do
       {
-        "state" => "in_progress",
-        "current_progress" => {"percent" => "1"},
-        "state_details" => { "is_final_state" => false },
-        "result" => "no_result",
+        'state' => 'in_progress',
+        'current_progress' => {'percent' => '1'},
+        'state_details' => { 'is_final_state' => false },
+        'result' => 'no_result',
       }
     end
 
     let(:complete_response) do
       {
-        "state" => "complete",
-        "current_progress" => {"percent" => "100"},
-        "state_details" => { "is_final_state" => true},
-        "result" => "passed",
+        'state' => 'complete',
+        'current_progress' => {'percent' => '100'},
+        'state_details' => { 'is_final_state' => true},
+        'result' => 'passed',
       }
     end
 
-    context "with bad parameters" do
-      context "no token" do
+    context 'with bad parameters' do
+      context 'no token' do
         let(:params) { %w(run --custom-url http://ad-hoc.example.com) }
         it 'errors out' do
           expect_any_instance_of(Logger).to receive(:fatal).with('You must pass your API token using: --token TOKEN')
-          expect {
+          expect do
             described_class.start(params)
-          }.to raise_error(SystemExit) { |error|
+          end.to raise_error(SystemExit) { |error|
             expect(error.status).to eq 2
           }
         end
       end
     end
 
-    context "git-trigger" do
+    context 'git-trigger' do
       let(:params) { %w(run --token x --git-trigger) }
       let(:commit_message) { 'a test commit message' }
 
@@ -52,156 +53,149 @@ describe RainforestCli do
       end
 
       before do
-        RainforestCli::GitTrigger.stub(:last_commit_message) { commit_message }
+        allow(RainforestCli::GitTrigger).to receive(:last_commit_message).and_return(commit_message)
       end
 
-      describe "with tags parameter passed" do
+      describe 'with tags parameter passed' do
         let(:params) { %w(run --token x --tag x --git-trigger) }
 
-        it "warns about the parameter being ignored" do
-          expect_any_instance_of(Logger).to receive(:warn).with("Specified tags are ignored when using --git-trigger")
+        it 'warns about the parameter being ignored' do
+          expect_any_instance_of(Logger).to receive(:warn).with('Specified tags are ignored when using --git-trigger')
 
           start_with_params(params, 0)
         end
       end
 
-      describe "without tags parameter passed" do
+      describe 'without tags parameter passed' do
         let(:params) { %w(run all --token x --git-trigger) }
 
-        it "warns about the parameter being ignored" do
-          expect_any_instance_of(Logger).to receive(:warn).with("Specified tests are ignored when using --git-trigger")
+        it 'warns about the parameter being ignored' do
+          expect_any_instance_of(Logger).to receive(:warn).with('Specified tests are ignored when using --git-trigger')
 
           start_with_params(params, 0)
         end
       end
 
-      describe "with no @rainforest in the commit message" do
+      describe 'with no @rainforest in the commit message' do
         it "exit 0's and logs the reason" do
-          expect_any_instance_of(Logger).to receive(:info).with("Not triggering as @rainforest was not mentioned in last commit message.")
+          expect_any_instance_of(Logger).to receive(:info)
+            .with('Not triggering as @rainforest was not mentioned in last commit message.')
           start_with_params(params, 0)
         end
       end
 
-      describe "with @rainforest in the commit message, but no tags" do
+      describe 'with @rainforest in the commit message, but no tags' do
         let(:commit_message) { 'a test commit message @rainforest' }
 
         it "exit 2's and logs the reason" do
-          expect_any_instance_of(Logger).to receive(:error).with("Triggered via git, but no hashtags detected. Please use commit message format:")
-          expect_any_instance_of(Logger).to receive(:error).with("\t'some message. @rainforest #tag1 #tag2")
+          expect_any_instance_of(Logger).to receive(:error)
+            .with('Triggered via git, but no hashtags detected. Please use commit message format:')
+          expect_any_instance_of(Logger).to receive(:error)
+            .with("\t'some message. @rainforest #tag1 #tag2")
 
           start_with_params(params, 2)
         end
       end
 
-      describe "with @rainforest in the commit message + hashtags" do
+      describe 'with @rainforest in the commit message + hashtags' do
         let(:commit_message) { 'a test commit message @rainforest #run-me' }
 
-        it "starts the run with the specified tags" do
-          http_client.should_receive(:post) do |url, options|
-            expect(url).to eq("/runs")
-            expect(options[:tags]).to eq(['run-me'])
-            {}
-          end
+        it 'starts the run with the specified tags' do
+          expect_any_instance_of(http_client).to receive(:post)
+            .with('/runs', tags: ['run-me']).and_return({})
 
           start_with_params(params, 0)
         end
       end
     end
 
-    context "with site-id and custom-url" do
+    context 'with site-id and custom-url' do
       let(:params) { %w(run --token x --site 3 --custom-url http://ad-hoc.example.com) }
-      it "creates a new environment" do
-        http_client.should_receive(:post).with("/environments",
-            {
-              :name => "temporary-env-for-custom-url-via-CLI",
-              :url=>"http://ad-hoc.example.com"
-            }
-          ).and_return(
-            { 'id' => 333 }
-          )
-
-        http_client.should_receive(:post).with("/runs", anything).and_return( { "id" => 1 } )
+      it 'creates a new environment' do
+        expect_any_instance_of(http_client).to receive(:post)
+          .with('/environments', name: 'temporary-env-for-custom-url-via-CLI', url: 'http://ad-hoc.example.com')
+          .and_return({ 'id' => 333 })
+
+        expect_any_instance_of(http_client).to receive(:post).with('/runs', anything)
+          .and_return({ 'id' => 1 })
 
         # This is a hack because when expecting a function to be called with
         # parameters, the last call is compared but I want to compare the first
         # call, not the call to create a run, so I exit, but rescue from it here
         # so that the spec doesn't fail. It's horrible, sorry!
+
+        # NOTE: start Rubocop exception
+        # rubocop:disable Lint/HandleExceptions
         begin
           described_class.start(params)
-        rescue SystemExit => e
+        rescue SystemExit
           # That's fine, this is expected but tested in a differnet assertion
         end
+        # rubocop:enable Lint/HandleExceptions
+        # NOTE: end Rubocop exception
       end
 
-      it "starts the run with site_id and environment_id" do
-        RainforestCli::Runner.any_instance.stub(get_environment_id: 333)
+      it 'starts the run with site_id and environment_id' do
+        allow_any_instance_of(RainforestCli::Runner).to receive(:get_environment_id).and_return(333)
 
-        http_client.should_receive(:post).with(
-          "/runs",
-          { :tests=>[], :site_id=>3, :environment_id=>333 }
-        ).and_return( {} )
+        expect_any_instance_of(http_client).to receive(:post).with(
+          '/runs',
+          { tests: [], site_id: 3, environment_id: 333 }
+        ).and_return({})
         described_class.start(params)
       end
     end
 
-    context "with environment-id" do
+    context 'with environment-id' do
       let(:params) { %w(run --token x --environment 123) }
 
-      it "starts the run with environment_id" do
-        RainforestCli::Runner.any_instance.stub(get_environment_id: 333)
+      it 'starts the run with environment_id' do
+        allow_any_instance_of(RainforestCli::Runner).to receive(:get_environment_id)
+          .and_return(333)
 
-        http_client.should_receive(:post).with(
-          "/runs",
-          { :tests=>[], :environment_id=>123 }
-        ).and_return( {} )
+        expect_any_instance_of(http_client).to receive(:post).with(
+          '/runs',
+          { tests: [], environment_id: 123 }
+        ).and_return({})
         described_class.start(params)
       end
     end
 
-    context "with smart_folder_id" do
+    context 'with smart_folder_id' do
       let(:params) { %w(run --token x --folder 123) }
 
-      it "starts the run with smart folder" do
-        http_client.should_receive(:post).with(
-          "/runs",
-          { :smart_folder_id=>123 }
-        ).and_return( {} )
+      it 'starts the run with smart folder' do
+        expect_any_instance_of(http_client).to receive(:post).with(
+          '/runs',
+          { smart_folder_id: 123 }
+        ).and_return({})
         described_class.start(params)
       end
     end
 
-    context "a simple run" do
+    context 'a simple run' do
       before do
-        http_client.stub(:post) { {"id" => 1} }
-        3.times do
-          http_client.should_receive(:get) { ok_progress }
-        end
-        http_client.should_receive(:get) { complete_response }
+        allow_any_instance_of(http_client).to receive(:post).and_return('id' => 1)
+        expect_any_instance_of(http_client).to receive(:get).exactly(3).times.and_return(ok_progress)
+        expect_any_instance_of(http_client).to receive(:get).and_return(complete_response)
       end
 
-      it "should return true" do
-        described_class.start(valid_args).should be_true
+      it 'should return true' do
+        expect(described_class.start(valid_args)).to eq(true)
       end
     end
 
-    context "a run where the server 500s after a while" do
+    context 'a run where the server 500s after a while' do
       before do
-        http_client.stub(:post) { {"id" => 1} }
-        2.times do
-          http_client.should_receive(:get) { ok_progress }
-        end
-
-        http_client.should_receive(:get) { nil }
-
-        2.times do
-          http_client.should_receive(:get) { ok_progress }
-        end
-
-        http_client.should_receive(:get) { complete_response }
+        allow_any_instance_of(http_client).to receive(:post).and_return('id' => 1)
+        expect_any_instance_of(http_client).to receive(:get).twice.and_return(ok_progress)
+        expect_any_instance_of(http_client).to receive(:get)
+        expect_any_instance_of(http_client).to receive(:get).twice.and_return(ok_progress)
+        expect_any_instance_of(http_client).to receive(:get).and_return(complete_response)
       end
 
-      it "should return true" do
-        described_class.start(valid_args).should be_true
+      it 'should return true' do
+        expect(described_class.start(valid_args)).to eq(true)
       end
     end
   end