falkorlib 0.6.18 → 0.6.19

data/spec/falkorlib/config_spec.rb

@@ -13,7 +13,7 @@ describe FalkorLib::Config do
                                :key => 'val'
                               }
                    }
-    
+
     after :all do
         FileUtils.remove_entry_secure dir
     end
@@ -24,19 +24,19 @@ describe FalkorLib::Config do
 		it "#default" do
             hash = FalkorLib::Config.default
             t = hash.is_a? Hash
-            t.should be_true
-            hash[:rvm][:versionfile].should == FalkorLib::Config::DEFAULTS[:rvm][:versionfile]
+            expect(t).to be true
+            expect(hash[:rvm][:versionfile]).to eq(FalkorLib::Config::DEFAULTS[:rvm][:versionfile])
         end
 
         it "#save" do
             FalkorLib::Config.save(dir, test_hash, :local, { :no_interaction => true })
             t = File.exists?( File.join(dir, FalkorLib::Config::DEFAULTS[:config_files][:local]))
-            t. should be_true
+            expect(t). to be true
         end
 
         it "#get" do
             h = FalkorLib::Config.get(dir, :local, { :no_interaction => true })
-            h.should == test_hash
+            expect(h).to eq(test_hash)
         end
 
 	end

data/spec/falkorlib/error_spec.rb

@@ -23,7 +23,7 @@ describe FalkorLib::Error do
                     raise e
                 rescue StandardError => s
                     i = s.status_code
-                    i.should == exceptions.index(e)
+                    expect(i).to eq(exceptions.index(e))
                 end
             end
         end

data/spec/falkorlib/git_spec.rb

@@ -2,7 +2,7 @@
 #########################################
 # git_spec.rb
 # @author Sebastien Varrette <Sebastien.Varrette@uni.lu>
-# Time-stamp: <Mon 2016-02-22 23:34 svarrette>
+# Time-stamp: <Sun 2016-10-16 22:05 svarrette>
 #
 # @description Check the Git operations
 #
@@ -34,19 +34,19 @@ describe FalkorLib::Git do
 
         it "#init? - fails on non-git directory" do
             t = FalkorLib::Git.init?(dir)
-            t.should be_false
+            expect(t).to be false
         end
 
         it "#init - initialize a git repository" do
             c = FalkorLib::Git.init(dir)
-            c.should == 0
+            expect(c).to eq(0)
             t = FalkorLib::Git.init?(dir)
-            t.should be_true
+            expect(t).to be true
         end
 
         it "#remotes? -- should be false" do
             t = FalkorLib::Git.remotes?(dir)
-            t.should be_false
+            expect(t).to be false
         end
 
         it "#rootdir #gitdir - checks git dir and working tree" do
@@ -55,59 +55,59 @@ describe FalkorLib::Git do
             Dir.chdir( subdir ) do
                 r = File.realpath( FalkorLib::Git.rootdir )
                 g = FalkorLib::Git.gitdir
-                r.should == File.realpath(dir)
-                g.should == File.realpath( File.join(dir, '.git')  )
+                expect(r).to eq(File.realpath(dir))
+                expect(g).to eq(File.realpath( File.join(dir, '.git')  ))
             end
         end
 
         it "#has_commits? - not yet any commits" do
             b = FalkorLib::Git.has_commits?( dir )
-            b.should be_false
+            expect(b).to be false
         end
 
         it "#branch? - check non-existing branch" do
             br = FalkorLib::Git.branch?( dir )
-            br.should be_nil
+            expect(br).to be_nil
         end
 
         it "#list_files -- should not list any files" do
             l = FalkorLib::Git.list_files( dir )
-            l.should be_empty
+            expect(l).to be_empty
         end
 
         it "#add - makes a first commit" do
             FileUtils.touch( afile )
             t = FalkorLib::Git.add(afile)
-            t.should == 0
+            expect(t).to eq(0)
         end
 
         it "#list_files -- should list a single files" do
             l = FalkorLib::Git.list_files( dir )
-            l.should include 'a_file'
+            expect(l).to include 'a_file'
         end
 
 
         it "#has_commits? - no some commits have been done" do
             b = FalkorLib::Git.has_commits?( dir )
-            b.should be_true
+            expect(b).to be true
         end
 
 
         it "#branch? - check existing branch" do
             br = FalkorLib::Git.branch?( dir )
-            br.should == 'master'
+            expect(br).to eq('master')
         end
 
         it "#dirty? - check non-dirty git directory" do
             b = FalkorLib::Git.dirty?( dir )
-            b.should be_false
+            expect(b).to be false
         end
 
         default_branches.each do |br|
             it "#create_branch #list_branch - creates branch #{br}" do
                 FalkorLib::Git.create_branch( br, dir )
                 l = FalkorLib::Git.list_branch( dir )
-                l.should include "#{br}"
+                expect(l).to include "#{br}"
             end
         end
 
@@ -115,70 +115,70 @@ describe FalkorLib::Git do
             it "#delete_branch #list_branch - deletes branch #{br}" do
                 FalkorLib::Git.delete_branch( br, dir) #, :force => true )
                 l = FalkorLib::Git.list_branch( dir )
-                l.should_not include "#{br}"
+                expect(l).not_to include "#{br}"
             end
         end
 
         it "#command? - check non-availability of git command 'toto'" do
             c = FalkorLib::Git.command?('toto')
-            c.should be_false
+            expect(c).to be false
         end
 
         it "#command? - check availability of git command 'init'" do
             c = FalkorLib::Git.command?('init')
-            c.should be_true
+            expect(c).to be true
         end
 
         it "#config -- check existing key" do
             c = FalkorLib::Git.config('user.name', dir)
-            c.should_not be_empty
+            expect(c).not_to be_empty
             t = c.is_a? String
-            t.should be_true
+            expect(t).to be true
         end
 
         it "#config -- check non-existing key" do
             c = FalkorLib::Git.config('user.nam', dir)
-            c.should be_nil
+            expect(c).to be_nil
         end
 
         it "#config -- check all keys" do
             c = FalkorLib::Git.config('*', dir)
-            c.should_not be_empty
+            expect(c).not_to be_empty
             t = c.is_a? Array
-            t.should be_true
+            expect(t).to be true
         end
 
         it "#config -- check pattern" do
             c = FalkorLib::Git.config('user*', dir)
-            c.should_not be_empty
+            expect(c).not_to be_empty
             t = c.is_a? Array
-            t.should be_true
+            expect(t).to be true
             ap c
-            c.length.should >= 2
+            expect(c.length).to be >= 2
         end
 
         it "#config -- check pattern 2" do
             c = FalkorLib::Git.config(/.*name=/, dir)
-            c.should_not be_empty
+            expect(c).not_to be_empty
             t = c.is_a? Array
-            t.should be_true
-            c.length.should == 1
+            expect(t).to be true
+            expect(c.length).to eq(1)
         end
 
         it "#config -- return hash" do
             c = FalkorLib::Git.config('user*', dir, :hash => true)
-            c.should_not be_empty
+            expect(c).not_to be_empty
             t = c.is_a? Hash
-            t.should be_true
+            expect(t).to be true
             ap c
-            c.keys.length.should >= 2
+            expect(c.keys.length).to be >= 2
         end
 
         it "#config -- check hash correctness" do
             key = 'user.name'
             c = FalkorLib::Git.config('user*', dir, :hash => true)
             n = FalkorLib::Git.config('user.name', dir)
-            n.should == c[ key ]
+            expect(n).to eq(c[ key ])
         end
 
         # ---------- Submodules ---------------
@@ -192,17 +192,17 @@ describe FalkorLib::Git do
                 }
             end
             b = FalkorLib::Git.submodule_init( dir )
-            b.should == 0
+            expect(b).to eq(0)
         end
 
         it "#submodules_update" do
             b = FalkorLib::Git.submodule_update( dir )
-            b.should == 0
+            expect(b).to eq(0)
         end
 
         it "#submodules_upgrade" do
             b = FalkorLib::Git.submodule_upgrade( dir )
-            b.should == 0
+            expect(b).to eq(0)
         end
 
         # ---------- Subtrees ---------------
@@ -218,28 +218,28 @@ describe FalkorLib::Git do
 
             it "#subtree_init? -- should check that the subtree(s) have not been initialized" do
                 b = FalkorLib::Git.subtree_init?( dir )
-                b.should be_false
+                expect(b).to be false
             end
 
             it "#subtree_init - initialize some Git Subtrees" do
 
                 b = FalkorLib::Git.subtree_init( dir )
-                b.should == 0
+                expect(b).to eq(0)
             end
 
             it "#subtree_init? -- should check that the subtree(s) have been initialized" do
                 b = FalkorLib::Git.subtree_init?( dir )
-                b.should be_true
+                expect(b).to be true
             end
 
             it "#subtree_up" do
                 b = FalkorLib::Git.subtree_up( dir )
-                b.should == 0
+                expect(b).to eq(0)
             end
 
             it "#subtree_diff" do
                 b = FalkorLib::Git.subtree_diff( dir )
-                b.should == 0
+                expect(b).to eq(0)
                 puts FalkorLib::Git.dirty?( dir )
             end
         end
@@ -251,7 +251,7 @@ describe FalkorLib::Git do
         it "#dirty? - check dirty git directory" do
             execute "echo 'toto' > #{afile}"
             b = FalkorLib::Git.dirty?( dir )
-            b.should be_true
+            expect(b).to be true
         end
 
     end

data/spec/falkorlib/gitflow_spec.rb

@@ -2,7 +2,7 @@
 #########################################
 # gitflow_spec.rb
 # @author Sebastien Varrette <Sebastien.Varrette@uni.lu>
-# Time-stamp: <Jeu 2015-01-22 15:52 svarrette>
+# Time-stamp: <Sun 2016-10-16 22:06 svarrette>
 #
 # @description Check the Git Flow operations -- see https://github.com/nvie/gitflow
 #
@@ -31,38 +31,38 @@ describe FalkorLib::GitFlow do
 
             it "#init? - fails on non-git directory" do
                 t = FalkorLib::GitFlow.init?(dir)
-                t.should be_false
-            end	
+                expect(t).to be false
+            end
 
             it "#init - initialize a git-flow repository" do
-                STDIN.should_receive(:gets).and_return('Yes')
+                expect(STDIN).to receive(:gets).and_return('Yes')
                 i = FalkorLib::GitFlow.init(dir)
-                i.should == 0
+                expect(i).to eq(0)
                 t = FalkorLib::Git.init?(dir)
-                t.should be_true
+                expect(t).to be true
             end
 
             it "#init? - succeed on git-flow enabled directory" do
                 t = FalkorLib::GitFlow.init?(dir)
-                t.should be_true
-            end	
+                expect(t).to be true
+            end
 
             #['feature', 'hotfix', 'support'].each do |op|
             ['feature'].each do |op|
                 name = 'toto'
                 it "#start -- should start a '#{op}' GitFlow operation" do
                     a = FalkorLib::GitFlow.start(op, name, dir)
-                    a.should == 0
+                    expect(a).to eq(0)
                     br = FalkorLib::Git.branch?( dir )
-                    br.should == "#{op}/#{name}"
+                    expect(br).to eq("#{op}/#{name}")
                 end
 
                 it "#finish -- should finish a '#{op}' GitFlow operation" do
-                    STDIN.should_receive(:gets).and_return("Test #{op} operation") if [ 'hotfix', 'support' ].include?(op)
+                    expect(STDIN).to receive(:gets).and_return("Test #{op} operation") if [ 'hotfix', 'support' ].include?(op)
                     a = FalkorLib::GitFlow.finish(op, name, dir)
-                    a.should == 0
+                    expect(a).to eq(0)
                     br = FalkorLib::Git.branch?( dir )
-                    br.should == FalkorLib.config[:gitflow][:branches][:develop]
+                    expect(br).to eq(FalkorLib.config[:gitflow][:branches][:develop])
                 end
             end
         end

data/spec/falkorlib/puppet_modules_spec.rb

@@ -2,7 +2,7 @@
 #########################################
 # puppet_modules_spec.rb
 # @author Sebastien Varrette <Sebastien.Varrette@uni.lu>
-# Time-stamp: <Tue 2015-06-16 10:12 svarrette>
+# Time-stamp: <Sun 2016-10-16 22:06 svarrette>
 #
 # @description Check the Puppet Modules operations
 #
@@ -16,172 +16,172 @@ require 'falkorlib/puppet'
 require 'json'
 
 describe FalkorLib::Puppet::Modules do
-    include FalkorLib::Common
-
-    dir   = Dir.mktmpdir
-	# Module name
-	name      = 'toto'
-	moduledir = File.join(dir, name)
-	jsonfile = File.join( moduledir, 'metadata.json') 
-
-    #afile = File.join(dir, 'a_file')
-    # before :all do
-    #   ENV['GIT_AUTHOR_NAME']  = 'travis'            if ENV['GIT_AUTHOR_NAME'].nil?
-    #   ENV['GIT_AUTHOR_EMAIL'] = 'travis@domain.org' if ENV['GIT_AUTHOR_EMAIL'].nil?
-    # end
-
-    after :all do
-        FileUtils.remove_entry_secure dir
+  include FalkorLib::Common
+
+  dir   = Dir.mktmpdir
+  # Module name
+  name      = 'toto'
+  moduledir = File.join(dir, name)
+  jsonfile = File.join( moduledir, 'metadata.json')
+
+  #afile = File.join(dir, 'a_file')
+  # before :all do
+  #   ENV['GIT_AUTHOR_NAME']  = 'travis'            if ENV['GIT_AUTHOR_NAME'].nil?
+  #   ENV['GIT_AUTHOR_EMAIL'] = 'travis@domain.org' if ENV['GIT_AUTHOR_EMAIL'].nil?
+  # end
+
+  after :all do
+    FileUtils.remove_entry_secure dir
+  end
+
+  #############################################################
+  context "Test Puppet Module creation within temporary directory " do
+
+
+    it "#init -- create a puppet module" do
+      # Prepare answer to the questions
+      Array.new(17).each { |e|  expect(STDIN).to receive(:gets).and_return('') }
+      FalkorLib::Puppet::Modules.init(moduledir)
+      templatedir = File.join( FalkorLib.templates, 'puppet', 'modules')
+      s = true
+      puts "templatedir = #{templatedir}"
+      Dir["#{templatedir}/**/*"].each  do |e|
+        next if File.directory?(e)
+        relative_dir = Pathname.new( File.realpath( File.dirname(e) )).relative_path_from Pathname.new(templatedir)
+        file = e.gsub(/templatename/, "#{name}")
+        filename = File.basename(file)
+        filename = File.basename(file, '.erb') unless file =~ /templates\/toto-variables\.erb/
+        f = File.join(moduledir, relative_dir, filename)
+        puts "checking #{f} - #{File.exists?( f )}"
+        s &= File.exists?( f )
+      end
+      expect(s).to be true
     end
 
-    #############################################################
-    context "Test Puppet Module creation within temporary directory " do
-
-
-        it "#init -- create a puppet module" do
-            # Prepare answer to the questions
-            Array.new(17).each { |e|  STDIN.should_receive(:gets).and_return('') }
-            FalkorLib::Puppet::Modules.init(moduledir)
-            templatedir = File.join( FalkorLib.templates, 'puppet', 'modules')
-            s = true
-			puts "templatedir = #{templatedir}"
-            Dir["#{templatedir}/**/*"].each  do |e|
-                next if File.directory?(e)
-                relative_dir = Pathname.new( File.realpath( File.dirname(e) )).relative_path_from Pathname.new(templatedir)
-                file = e.gsub(/templatename/, "#{name}")
-                filename = File.basename(file)
-                filename = File.basename(file, '.erb') unless file =~ /templates\/toto-variables\.erb/ 
-                f = File.join(moduledir, relative_dir, filename)
-                puts "checking #{f} - #{File.exists?( f )}"
-                s &= File.exists?( f )
-            end
-            s.should be_true
-        end
-
-		it "#_getclassdefs -- should failed on unrecogized type" do
-			expect { FalkorLib::Puppet::Modules._get_classdefs(dir, 'toto') }.to raise_error (SystemExit)
-		end
-
-
-        it "#classes -- list classes" do
-            l = FalkorLib::Puppet::Modules._get_classdefs(moduledir, 'classes')
-            c = FalkorLib::Puppet::Modules.classes(moduledir)
-            c.should == l
-            ref =  [
-                    "toto::params",
-                    "toto",
-                    "toto::common",
-                    "toto::common::debian",
-                    "toto::common::redhat"
-                   ]
-            c.size.should == ref.size
-            c.each { |e| ref.should include(e) }
-        end
-
-        it "#definitions -- list definitions" do
-            d = FalkorLib::Puppet::Modules.definitions(moduledir)
-            d.should == [ "toto::mydef" ]
-        end
-
-        it "#deps -- list dependencies" do
-            d = FalkorLib::Puppet::Modules.deps(moduledir)
-            d.should == []
-        end
-
-		it "#metadata" do
-			ref = JSON.parse( IO.read( jsonfile ) )
-			metadata = FalkorLib::Puppet::Modules.metadata(moduledir, { 
-				                                               :use_symbols => false,
-				                                               :extras      => false
-			                                               })
-			ref.keys.each do |k|
-				metadata[k].should == ref[k] 
-			end
-		end
-
-
-        it "#parse" do
-            #STDIN.should_receive(:gets).and_return('')
-            ref = JSON.parse( IO.read( jsonfile ) )
-			metadata = FalkorLib::Puppet::Modules.parse(moduledir, { :no_interaction => true })
-			diff = (metadata.to_a - ref.to_a).flatten.sort
-            diff.should == [
-                            'classes',
-                            'definitions',
-                            'toto',
-                            'toto::common',
-                            'toto::common::debian',
-                            'toto::common::redhat',
-                            'toto::mydef',
-                            'toto::params',
-                           ]
-        end
-
-		it "#parse again -- should not exhibit any difference" do
-			ref = JSON.parse( IO.read( jsonfile ) )
-			metadata = FalkorLib::Puppet::Modules.parse(moduledir, { :no_interaction => true })
-			diff = (metadata.to_a - ref.to_a).flatten.sort
-			diff.should == []
-		end
-
-		it "#deps -- should find a new dependency" do
-			classfile = File.join(moduledir, 'manifests', 'init.pp')
-			newdep = "tata"
-			run %{ echo 'include "#{newdep}"' >> #{classfile} }
-			a = FalkorLib::Puppet::Modules.deps(moduledir)
-			a.should include newdep 
-		end
-
-		it "#parse again -- should ask new dependency elements" do
-			ref      = JSON.parse( IO.read( jsonfile ) )
-			STDIN.should_receive(:gets).and_return('svarrette')
-			STDIN.should_receive(:gets).and_return('1.2')
-			STDIN.should_receive(:gets).and_return('Yes')
-			STDIN.should_receive(:gets).and_return('')
-			metadata = FalkorLib::Puppet::Modules.parse(moduledir)
-			diff = (metadata.to_a - ref.to_a).flatten
-			diff.should == [
-			                'dependencies',
-			                {"name"=>"puppetlabs-stdlib", "version_requirement"=>">=4.2.2 <5.0.0"}, 
-			                {"name"=>"svarrette/tata", "version_requirement"=>"1.2"}
-			               ]
-		end
-
-		upgraded_files_default = 1
-		it "#upgrade" do
-			d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
-				                                       :no_interaction => true
-			                                       })
-            d.should == upgraded_files_default
-		end
-
-		it "#upgrade -- with only a subset of files" do
-			d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
-				                                       :no_interaction => true,
-				                                       :only => [ 'README.md', 'Gemfile']
-			                                       })
-			d.should == 0
-		end
-
-		it "#upgrade -- exclude some files" do
-			d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
-				                                       :no_interaction => true, 
-				                                       :exclude => [ 'README.md']
-			                                       })
-            d.should == 0
-            #d.should == (upgraded_files_default - 1)
-		end
-
-		it "#upgrade -- both include and exclude files" do
-			d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
-				                                       :no_interaction => true, 
-				                                       :only    => [ 'README.md'],
-				                                       :exclude => [ 'README.md']
-			                                       })
-			d.should == 0
-		end
-
-
-    end # context
+    it "#_getclassdefs -- should failed on unrecogized type" do
+      expect { FalkorLib::Puppet::Modules._get_classdefs(dir, 'toto') }.to raise_error (SystemExit)
+    end
+
+
+    it "#classes -- list classes" do
+      l = FalkorLib::Puppet::Modules._get_classdefs(moduledir, 'classes')
+      c = FalkorLib::Puppet::Modules.classes(moduledir)
+      expect(c).to eq(l)
+      ref =  [
+        "toto::params",
+        "toto",
+        "toto::common",
+        "toto::common::debian",
+        "toto::common::redhat"
+      ]
+      expect(c.size).to eq(ref.size)
+      c.each { |e| expect(ref).to include(e) }
+    end
+
+    it "#definitions -- list definitions" do
+      d = FalkorLib::Puppet::Modules.definitions(moduledir)
+      expect(d).to eq([ "toto::mydef" ])
+    end
+
+    it "#deps -- list dependencies" do
+      d = FalkorLib::Puppet::Modules.deps(moduledir)
+      expect(d).to eq([])
+    end
+
+    it "#metadata" do
+      ref = JSON.parse( IO.read( jsonfile ) )
+      metadata = FalkorLib::Puppet::Modules.metadata(moduledir, {
+                                                       :use_symbols => false,
+                                                       :extras      => false
+                                                     })
+      ref.keys.each do |k|
+        expect(metadata[k]).to eq(ref[k])
+      end
+    end
+
+
+    it "#parse" do
+      #STDIN.should_receive(:gets).and_return('')
+      ref = JSON.parse( IO.read( jsonfile ) )
+      metadata = FalkorLib::Puppet::Modules.parse(moduledir, { :no_interaction => true })
+      diff = (metadata.to_a - ref.to_a).flatten.sort
+      expect(diff).to eq([
+        'classes',
+        'definitions',
+        'toto',
+        'toto::common',
+        'toto::common::debian',
+        'toto::common::redhat',
+        'toto::mydef',
+        'toto::params',
+      ])
+    end
+
+    it "#parse again -- should not exhibit any difference" do
+      ref = JSON.parse( IO.read( jsonfile ) )
+      metadata = FalkorLib::Puppet::Modules.parse(moduledir, { :no_interaction => true })
+      diff = (metadata.to_a - ref.to_a).flatten.sort
+      expect(diff).to eq([])
+    end
+
+    it "#deps -- should find a new dependency" do
+      classfile = File.join(moduledir, 'manifests', 'init.pp')
+      newdep = "tata"
+      run %{ echo 'include "#{newdep}"' >> #{classfile} }
+      a = FalkorLib::Puppet::Modules.deps(moduledir)
+      expect(a).to include newdep
+    end
+
+    it "#parse again -- should ask new dependency elements" do
+      ref      = JSON.parse( IO.read( jsonfile ) )
+      expect(STDIN).to receive(:gets).and_return('svarrette')
+      expect(STDIN).to receive(:gets).and_return('1.2')
+      expect(STDIN).to receive(:gets).and_return('Yes')
+      expect(STDIN).to receive(:gets).and_return('')
+      metadata = FalkorLib::Puppet::Modules.parse(moduledir)
+      diff = (metadata.to_a - ref.to_a).flatten
+      expect(diff).to eq([
+        'dependencies',
+        {"name"=>"puppetlabs-stdlib", "version_requirement"=>">=4.2.2 <5.0.0"},
+        {"name"=>"svarrette/tata", "version_requirement"=>"1.2"}
+      ])
+    end
+
+    upgraded_files_default = 1
+    it "#upgrade" do
+      d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
+                                               :no_interaction => true
+                                             })
+      expect(d).to eq(upgraded_files_default)
+    end
+
+    it "#upgrade -- with only a subset of files" do
+      d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
+                                               :no_interaction => true,
+                                               :only => [ 'README.md', 'Gemfile']
+                                             })
+      expect(d).to eq(0)
+    end
+
+    it "#upgrade -- exclude some files" do
+      d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
+                                               :no_interaction => true,
+                                               :exclude => [ 'README.md']
+                                             })
+      expect(d).to eq(0)
+      #d.should == (upgraded_files_default - 1)
+    end
+
+    it "#upgrade -- both include and exclude files" do
+      d = FalkorLib::Puppet::Modules.upgrade(moduledir, {
+                                               :no_interaction => true,
+                                               :only    => [ 'README.md'],
+                                               :exclude => [ 'README.md']
+                                             })
+      expect(d).to eq(0)
+    end
+
+
+  end # context
 
 end