falkorlib 0.6.18 → 0.6.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d745eb3bcd94aa27c60e45fab7c691aee85d3c0
-  data.tar.gz: 36aa55df010f3b05816d13e9795625ebdba47d62
+  metadata.gz: 2991193ba63366cf054fbf23cafb5b36dfaa2bc9
+  data.tar.gz: 59f153625348b86b00d58631c88c8fd4635f8b67
 SHA512:
-  metadata.gz: 971806266da376608f5c867d232274b0d00d23e6a68e762db2fc68fc0c641ca7cf55180ca50312697f4b44c7b819e41b115fb26042c8e75c8d11b22474d8fc8d
-  data.tar.gz: 4f56c78980b1fd8053b94c9409a9e854ff7b84403894766cb722c32d274cd9633a539b42d8716afb023d581aeb06c3b19175557c58865b6d953ea56d98a65f86
+  metadata.gz: d8907de32c3abb0988912fc1165501d946f1fc9bdfb7f50aeeb6a838edea4346915a9407bc6c6dc0dc757a805a3ce47e3efc39e0e83906bc790c783e6485ffe6
+  data.tar.gz: c9dda2e193d2c72a498c60b631aeba60044d842f3131108c9f788b1bf8d8c80dca172ee1cef07610ee180a7b6eb3fa876b375a0b0cc9a1f97fdc40e9ed15eb34

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    falkorlib (0.6.18)
+    falkorlib (0.6.19)
       artii (>= 2.1)
       awesome_print (~> 1.2)
       configatron (~> 3.2)
@@ -30,6 +30,7 @@ GEM
     coderay (1.1.0)
     configatron (3.2.0)
     deep_merge (1.0.1)
+    diff-lcs (1.2.5)
     diffy (3.1.0)
     docile (1.1.5)
     ethon (0.7.0)
@@ -71,6 +72,19 @@ GEM
       json
       websocket (~> 1.0)
     rake (10.5.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
     rubygems-tasks (0.2.4)
     safe_yaml (0.9.7)
     simplecov (0.8.2)
@@ -112,6 +126,7 @@ DEPENDENCIES
   falkorlib!
   pry
   rake
+  rspec (~> 3.0)
   rubygems-tasks (~> 0.2)
   thor-zsh_completion
   travis (~> 1.6)
@@ -119,4 +134,4 @@ DEPENDENCIES
   yard (~> 0.8)
 
 BUNDLED WITH
-   1.11.2
+   1.13.5

data/falkorlib.gemspec

@@ -95,7 +95,7 @@ Gem::Specification.new do |s|
   #
   #s.add_development_dependency("rake",           ">= 10.1.0") #"~> 0.9.2")
   s.add_development_dependency("bundler",        "~> 1.0")
-  #s.add_development_dependency 'rspec', '~> 2.7', '>= 2.7.0'
+  s.add_development_dependency 'rspec', '~> 3.0'   #, '>= 2.7.0'
   s.add_development_dependency("pry",    "~> 0.9")
   s.add_development_dependency("yard",   "~> 0.8")
   #s.add_development_dependency("minitest",   "~> 5.3")

data/lib/falkorlib/tasks/rspec.rake

@@ -25,6 +25,7 @@
 # rspec and options of the rake task defined below can be found on
 # http://relishapp.com/rspec
 #
+require 'rspec/core'
 begin
     require "rspec/core/rake_task"
     desc "Run RSpec code examples '*_spec.rb' from the spec/ directory"
@@ -50,19 +51,19 @@ begin
         t.verbose = true
 
         # Use rcov for code coverage?
-        t.rcov = false
+        #t.rcov = false
 
         # Path to rcov.
-        t.rcov_path = "rcov"
+        #t.rcov_path = "rcov"
 
         # Command line options to pass to rcov. See 'rcov --help' about this
-        t.rcov_opts = []
+        #t.rcov_opts = []
 
         # Command line options to pass to ruby. See 'ruby --help' about this
         t.ruby_opts = []
 
         # Path to rspec
-        t.rspec_path = "rspec"
+        #t.rspec_path = "rspec"
 
         # Command line options to pass to rspec. See 'rspec --help' about this
         #t.rspec_opts = ["--color", "--backtrace"]

data/lib/falkorlib/version.rb

@@ -19,7 +19,7 @@ module FalkorLib #:nodoc:
         # MAJOR: Defines the major version
         # MINOR: Defines the minor version
         # PATCH: Defines the patch version
-	    MAJOR, MINOR, PATCH = 0, 6, 18
+	    MAJOR, MINOR, PATCH = 0, 6, 19
 
 	    module_function
 

data/spec/falkorlib/bootstrap_helpers_spec.rb

@@ -2,7 +2,7 @@
 #########################################
 # bootstrap_spec.rb
 # @author Sebastien Varrette <Sebastien.Varrette@uni.lu>
-# Time-stamp: <Tue 2016-06-28 18:37 svarrette>
+# Time-stamp: <Sun 2016-10-16 22:02 svarrette>
 #
 # @description Check the Bootstrapping operations
 #
@@ -32,22 +32,22 @@ describe FalkorLib::Bootstrap do
 
     context 'helper functions' do
         it "#select_forge - none" do
-            STDIN.should_receive(:gets).and_return('1')
+            expect(STDIN).to receive(:gets).and_return('1')
             t = FalkorLib::Bootstrap.select_forge()
-            t.should == :none
+            expect(t).to eq(:none)
         end
 
         it "#select_forge -- default to github" do
-            STDIN.should_receive(:gets).and_return('')
+            expect(STDIN).to receive(:gets).and_return('')
             t = FalkorLib::Bootstrap.select_forge(:github)
-            t.should == :github
+            expect(t).to eq(:github)
         end
 
         FalkorLib::Config::Bootstrap::DEFAULTS[:licenses].keys.each do |lic|
             it "#select_licence -- default to #{lic}" do
-                STDIN.should_receive(:gets).and_return('')
+                expect(STDIN).to receive(:gets).and_return('')
                 t = FalkorLib::Bootstrap.select_licence(lic)
-                t.should == lic
+                expect(t).to eq(lic)
             end
         end
 
@@ -56,8 +56,8 @@ describe FalkorLib::Bootstrap do
             subject = 'licence'
             status  = 'GPL-2.0'
             t = FalkorLib::Bootstrap.get_badge(subject, status)
-            t.should =~ /#{subject}/
-            t.should =~ /#{status.sub(/-/, '--')}/
+            expect(t).to match(/#{subject}/)
+            expect(t).to match(/#{status.sub(/-/, '--')}/)
         end
     end # context
 
@@ -77,7 +77,7 @@ describe FalkorLib::Bootstrap do
             motdfile = File.join(dir, 'motd1')
             FalkorLib::Bootstrap.motd(dir, { :file => "#{motdfile}", :no_interaction => true })
             t = File.exists?(motdfile)
-            t.should be_true
+            expect(t).to be true
         end
     end
 

data/spec/falkorlib/bootstrap_spec.rb

@@ -2,7 +2,7 @@
 #########################################
 # bootstrap_spec.rb
 # @author Sebastien Varrette <Sebastien.Varrette@uni.lu>
-# Time-stamp: <Tue 2016-06-28 18:37 svarrette>
+# Time-stamp: <Sun 2016-10-16 22:05 svarrette>
 #
 # @description Check the Bootstrapping operations
 #
@@ -45,9 +45,9 @@ describe FalkorLib::Bootstrap do
             if ctx == :with_git
                 it "initialize Git in the temporary directory #{dir}" 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
             end
 
@@ -55,44 +55,44 @@ describe FalkorLib::Bootstrap do
             it "#trash" do
                 c = FalkorLib::Bootstrap.trash(dir)
                 t = File.exists?( File.join(dir, FalkorLib.config[:templates][:trashdir], '.gitignore'))
-                t.should be_true
-                c.should == 0
+                expect(t).to be true
+                expect(c).to eq(0)
             end
 
             it "#trash - repeat on an existing trash dir" do
                 c = FalkorLib::Bootstrap.trash(dir)
-                c.should == 1
+                expect(c).to eq(1)
             end
 
             it "#trash - change target trash dir" do
                 newtrashname = 'tmp/mytrash'
                 c = FalkorLib::Bootstrap.trash(dir,newtrashname)
                 t = File.exists?( File.join(dir, newtrashname, '.gitignore'))
-                t.should be_true
-                c.should == 0
+                expect(t).to be true
+                expect(c).to eq(0)
             end
 
             ######### RVM #########
             it "#rvm" do
                 gemset = File.basename(dir)
-                STDIN.should_receive(:gets).and_return('1') if ctx == :without_git
-                STDIN.should_receive(:gets).and_return('')  if ctx == :without_git
+                expect(STDIN).to receive(:gets).and_return('1') if ctx == :without_git
+                expect(STDIN).to receive(:gets).and_return('')  if ctx == :without_git
                 c = FalkorLib::Bootstrap.rvm(dir)
-                c.should == 0
+                expect(c).to eq(0)
                 content = {}
                 [:versionfile, :gemsetfile].each do |type|
                     f = File.join(dir, FalkorLib.config[:rvm][type.to_sym])
                     t = File.exists?(f)
-                    t.should be_true
+                    expect(t).to be true
                     content[type.to_sym] = `cat #{f}`.chomp
                 end
-                content[:versionfile].should == FalkorLib.config[:rvm][:rubies][0]
-                content[:gemsetfile].should  == gemset
+                expect(content[:versionfile]).to eq(FalkorLib.config[:rvm][:rubies][0])
+                expect(content[:gemsetfile]).to  eq(gemset)
             end
 
             it "#rvm -- repeat" do
                 c = FalkorLib::Bootstrap.rvm(dir)
-                c.should == 1
+                expect(c).to eq(1)
             end
 
             it "#rvm -- change targets (ctx = #{ctx}; dir = #{dir})" do
@@ -103,15 +103,15 @@ describe FalkorLib::Bootstrap do
                     :gemsetfile  => '.mygemset'
                 }
                 c = FalkorLib::Bootstrap.rvm(dir, opts)
-                c.should == 0
+                expect(c).to eq(0)
                 content = {}
                 [:versionfile, :gemsetfile].each do |type|
                     f = File.join("#{dir}", opts[type.to_sym])
                     t = File.exists?(f)
                     content[type.to_sym] = `cat #{f}`.chomp
                 end
-                content[:versionfile].should == opts[:ruby]
-                content[:gemsetfile].should  == opts[:gemset]
+                expect(content[:versionfile]).to eq(opts[:ruby])
+                expect(content[:gemsetfile]).to  eq(opts[:gemset])
             end
 
 
@@ -123,7 +123,7 @@ describe FalkorLib::Bootstrap do
                 FalkorLib.config[:no_interaction] = true
                 FalkorLib::Bootstrap.readme(dir, { :no_interaction => true })
                 t = File.exists?(File.join(dir, 'README.md'))
-                t.should be_true
+                expect(t).to be true
                 FalkorLib.config[:no_interaction] = false
             end
 
@@ -139,9 +139,9 @@ describe FalkorLib::Bootstrap do
                                                      :no_interaction => true
                                                  })
                 t = File.exists?(File.join(dir, file))
-                t.should be_true
+                expect(t).to be true
                 v = FalkorLib::Versioning.get_version(dir, { :source => { :filename => file }})
-                v.should == "#{version}"
+                expect(v).to eq("#{version}")
             end
 
         end # context

data/spec/falkorlib/common_spec.rb

@@ -39,7 +39,7 @@ describe FalkorLib::Common do
         # Check the color functions
         @print_test_conf.values.collect{ |e| e[:color] }.each do |color|
 			it "##{color} - check #{color} text" do
-                STDOUT.should_receive(:puts).with(send("#{color}", "#{color} text"))
+                expect(STDOUT).to receive(:puts).with(send("#{color}", "#{color} text"))
                 puts send("#{color}", "#{color} text")
             end
         end
@@ -47,11 +47,11 @@ describe FalkorLib::Common do
         # Check the prining messages
         @print_test_conf.each do |method,conf|
 			it "##{method} - put a #{method} message" do
-                ((method == :error) ? STDERR : STDOUT).should_receive(:puts).with(send("#{conf[:color]}", "#{conf[:prefix]} #{method} text"))
+                expect((method == :error) ? STDERR : STDOUT).to receive(:puts).with(send("#{conf[:color]}", "#{conf[:prefix]} #{method} text"))
                 if (method == :error)
-                    lambda {
+                    expect {
                         send("#{method}", "#{method} text")
-                    }.should raise_error #(SystemExit)
+                    }.to raise_error #(SystemExit)
                 else
                     send("#{method}", "#{method} text")
                 end
@@ -62,18 +62,18 @@ describe FalkorLib::Common do
         ['', 'default'].each do |default_answer|
             @query = "Am I a query"
             it "#ask - ask '#{@query}' with default answer '#{default_answer}' and no answer" do
-                STDIN.should_receive(:gets).and_return('')
+                expect(STDIN).to receive(:gets).and_return('')
                 results = capture(:stdout) {
                     answer = ask(@query, default_answer)
                     if default_answer.empty?
-                        answer.should be_empty
+                        expect(answer).to be_empty
                     else
-                        answer.should == default_answer
+                        expect(answer).to eq(default_answer)
                     end
                 }
-                results.should =~ /#{@query}/;
+                expect(results).to match(/#{@query}/);
                 unless default_answer.empty?
-                    results.should =~ /Default: #{default_answer}/;
+                    expect(results).to match(/Default: #{default_answer}/);
                 end
             end
         end
@@ -81,48 +81,48 @@ describe FalkorLib::Common do
         # Check the really_continue? function
         [ '', 'Yes', 'y', 'Y', 'yes' ].each do |answer|
             it "#really_continue? - should really continue after answer '#{answer}'" do
-                STDIN.should_receive(:gets).and_return(answer)
+                expect(STDIN).to receive(:gets).and_return(answer)
                 results = capture(:stdout) { really_continue? }
-                results.should =~ /=> Do you really want to continue/;
-                results.should =~ /Default: Yes/;
+                expect(results).to match(/=> Do you really want to continue/);
+                expect(results).to match(/Default: Yes/);
             end
             next if answer.empty?
             it "#really_continue? - should really continue (despite default answer 'No') after answer '#{answer}'" do
-                STDIN.should_receive(:gets).and_return(answer)
+                expect(STDIN).to receive(:gets).and_return(answer)
                 results = capture(:stdout) { really_continue?('No') }
-                results.should =~ /=> Do you really want to continue/;
-                results.should =~ /Default: No/;
+                expect(results).to match(/=> Do you really want to continue/);
+                expect(results).to match(/Default: No/);
             end
         end
 
         [ '', 'No', 'n', 'N', 'no' ].each do |answer|
             it "#really_continue? - should not continue (despite default answer 'No') and exit after answer '#{answer}'" do
-                STDIN.should_receive(:gets).and_return(answer)
+                expect(STDIN).to receive(:gets).and_return(answer)
                 results = capture(:stdout) {
-                    lambda{
+                    expect{
                         really_continue?('No')
-                    }.should raise_error (SystemExit)
+                    }.to raise_error (SystemExit)
                 }
-                results.should =~ /=> Do you really want to continue/;
-                results.should =~ /Default: No/;
+                expect(results).to match(/=> Do you really want to continue/);
+                expect(results).to match(/Default: No/);
             end
             next if answer.empty?
             it "#really_continue? - should not continue and exit after answer '#{answer}'" do
-                STDIN.should_receive(:gets).and_return(answer)
+                expect(STDIN).to receive(:gets).and_return(answer)
                 results = capture(:stdout) {
-                    lambda{
+                    expect{
                         really_continue?
-                    }.should raise_error (SystemExit)
+                    }.to raise_error (SystemExit)
                 }
-                results.should =~ /=> Do you really want to continue/;
-                results.should =~ /Default: Yes/;
+                expect(results).to match(/=> Do you really want to continue/);
+                expect(results).to match(/Default: Yes/);
             end
         end
 
         # Check the command? function
         [ 'sqgfyueztruyjf', 'ruby' ].each do |command|
             it "#command? - check the command '#{command}'" do
-                command?(command).should ((command == 'ruby') ? be_true : be_false)
+                expect(command?(command)).to be ((command == 'ruby') ? true : false)
             end
         end
    end
@@ -131,38 +131,38 @@ describe FalkorLib::Common do
 		b = capture(:stdout) {
 			nice_execute("echo toto")
 		}
-		b.split("\n").should include '** [out] toto'
+		expect(b.split("\n")).to include '** [out] toto'
 	end
 
 	it "#nice_execute -- check stderr output" do
 		b = capture(:stderr) {
 			nice_execute("echo 'toto' 1>&2")
 		}
-		b.should == red("** [err] toto\n")
+		expect(b).to eq(red("** [err] toto\n"))
 	end
 
 	it "#execute" do
 		b = execute("echo toto")
-		b.to_i.should == 0
+		expect(b.to_i).to eq(0)
 	end
 
 	it "#not_implemented" do
 		b = capture(:stderr) {
 			expect { not_implemented }.to raise_error (SystemExit)
 		}
-		b.should =~ /NOT YET IMPLEMENTED/
+		expect(b).to match(/NOT YET IMPLEMENTED/)
 	end
 
 	it "#exec_or_exit - should exit" do
 		expect { exec_or_exit "false" }.to raise_error (SystemExit)
 	end
 	it "#exec_or_exit - should NOT exit" do
-		expect { exec_or_exit "true" }.not_to raise_error (SystemExit)
+		expect { exec_or_exit "true" }.not_to raise_error # (SystemExit)
 	end
 
 	it "#execute_in_dir -- should execute the command in /tmp" do
 		b = execute_in_dir('/tmp', "pwd | grep -Fq '/tmp'")
-		b.should == 0
+		expect(b).to eq(0)
 	end
 
 
@@ -171,7 +171,7 @@ describe FalkorLib::Common do
             echo toto
             echo tata
         }
-		b.to_i.should == 0
+		expect(b.to_i).to eq(0)
 	end
 
 
@@ -180,9 +180,9 @@ describe FalkorLib::Common do
 
 		it "#load_config - load the correct hash from YAML" do
 			file_config = {:domain => "foo.com", :nested => { 'a1' => 2 }}
-			YAML.stub(:load_file).and_return(file_config)
+			allow(YAML).to receive(:load_file).and_return(file_config)
 			loaded = load_config('/tmp')  # /tmp to ensure existing target
-			loaded.should == file_config
+			expect(loaded).to eq(file_config)
 		end
 
 		it "#store_config - should store the correct hash to YAML" do
@@ -190,7 +190,7 @@ describe FalkorLib::Common do
 			f = Tempfile.new('toto')
 			store_config(f.path, file_config, { :no_interaction => true })
 			copy_file_config = YAML::load_file(f.path)
-			copy_file_config.should == file_config
+			expect(copy_file_config).to eq(file_config)
 		end
 
 	end
@@ -199,32 +199,32 @@ describe FalkorLib::Common do
 	context 'Test list selection functions' do
 
 		it "#list_items - Exit on 0" do
-			STDIN.should_receive(:gets).and_return('0')
+			expect(STDIN).to receive(:gets).and_return('0')
 			expect { list_items("#{dir}/*") }.to raise_error (SystemExit)
 		end
 
 		it "#list_items -- select files only" do
-			STDIN.should_receive(:gets).and_return('1')
+			expect(STDIN).to receive(:gets).and_return('1')
 			f = list_items("#{dir}/*", { :only_files => true })
-			f.should =~ /\/file.?\.txt$/
+			expect(f).to match(/\/file.?\.txt$/)
 		end
 
 		it "#list_items -- select files only with pattern exclude" do
-			STDIN.should_receive(:gets).and_return('1')
+			expect(STDIN).to receive(:gets).and_return('1')
 			f = list_items("#{dir}/*", { :only_files => true, :pattern_exclude => [ 'file1' ] })
-			f.should == "#{dir}/file2.txt"
+			expect(f).to eq("#{dir}/file2.txt")
 		end
 
 		it "#list_items -- select dirs only" do
-			STDIN.should_receive(:gets).and_return('1')
+			expect(STDIN).to receive(:gets).and_return('1')
 			f = list_items("#{dir}/*", { :only_dirs => true })
-			f.should =~ /\/dir.?$/
+			expect(f).to match(/\/dir.?$/)
 		end
 
 		it "#list_items -- select dirs only with pattern exclude" do
-			STDIN.should_receive(:gets).and_return('1')
+			expect(STDIN).to receive(:gets).and_return('1')
 			f = list_items("#{dir}/*", { :only_dirs => true, :pattern_exclude => [ 'dir1' ] })
-			f.should == "#{dir}/dir2"
+			expect(f).to eq("#{dir}/dir2")
 		end
 
 		it "#list_items -- exit on empty list" do