methodic 1.2 → 1.3

data/methodic.gemspec

@@ -1,18 +1,23 @@
 Gem::Specification.new do |s|
   s.name = %q{methodic}
   s.author = "Romain GEORGES"
-  s.version = "1.2"
+  s.version = "1.3"
   s.date = %q{2013-02-18}
   s.summary = %q{Methodic : Hash table options specification and validation componant}
   s.email = %q{romain@ultragreen.net}
-  s.homepage = %q{http://www.ultragreen.net}
+  s.homepage = %q{https://github.com/Ultragreen/methodic}
   s.description = %q{Methodic : provide Hash table options arguments manager (specifications and validations}
-  s.has_rdoc = true
-  s.files = Dir['*/*/*/*'] + Dir['*/*/*'] + Dir['*/*'] + Dir['*']
-  s.bindir = nil
-  s.required_ruby_version = '>= 1.8.1'
-  s.add_development_dependency "rspec", ">= 2.0.0"
-  s.rdoc_options << '--title' << 'Methodic : Gem documentation' << '--main' << 'doc/manual.rdoc' << '--line-numbers' 
+  s.files = `git ls-files`.split($/)
+  s.require_paths = ["lib"]
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.add_development_dependency 'rake', '~> 13.0.1'
+  s.add_development_dependency 'rspec', '~> 3.9.0'
+  s.add_development_dependency 'yard', '~> 0.9.24'
+  s.add_development_dependency 'rdoc', '~> 6.2.1'
+  s.add_development_dependency 'roodi', '~> 5.0.0'
+  s.add_development_dependency 'code_statistics', '~> 0.2.13'
+  s.add_development_dependency 'yard-rspec', '~> 0.1'
+  s.rdoc_options << '--title' << 'Methodic : Gem documentation' << '--main' << 'doc/manual.rdoc' << '--line-numbers'
   # << '--diagram'
-  s.rubyforge_project = "nowarning"
-end
+  s.license = "BSD-2-Clause"
+end

data/spec/methodic_spec.rb

@@ -1,203 +1,205 @@
 require'rubygems'
 require'rspec'
-require 'lib/methodic'
+require 'methodic'
 
 describe Methodic do
- 
+
   before :all do
     $test_methodic_options = Methodic::get_options :name => 'Doe', :surname => 'John'
     $test_methodic_options_with_known_options = Methodic::get_options({:name => 'Doe', :surname => 'John'},true)
   end
-  before :each do 
+  before :each do
     $test_methodic_options.mandatories.clear
     $test_methodic_options.formats = {}
     $test_methodic_options.defaults = {}
     $test_methodic_options.classes = {}
   end
   subject { Methodic }
-  specify { subject.should be_an_instance_of Module}
-  context Methodic::Options do 
+  specify { expect(subject).to be_an_instance_of Module}
+  context Methodic::Options do
     subject { Methodic::Options }
-    specify { subject.should be_an_instance_of Class }
+    specify { expect(subject).to be_an_instance_of Class }
     it "should respond to all methods of a Hash" do
       Hash::new.methods.each do |method|
-        $test_methodic_options.should respond_to(method)
+        expect($test_methodic_options).to respond_to(method)
       end
     end
     context "#new(_options) (initialization)" do
       context "Exception case" do
          it "should raise ArgumentError if _options is not a Hash" do
            [ 'a string', 12 ,Array::new,true,false].each do |item|
-             lambda{ Methodic::Options::new(item)}.should raise_error ArgumentError
+             expect { Methodic::Options::new(item) }.to raise_error(ArgumentError)
+
            end
          end
-        it "should not raise ArgumentError if no arg is passed to initializer" do
-          lambda{ Methodic::Options::new}.should_not raise_error 
-        end
-        it "should not raise ArgumentError if an Hash arg is passed to initializer" do
-          lambda{ Methodic::Options::new  :name => 'Doe' }.should_not raise_error
-        end
         it "should raise ArgumentError if an Hash arg is passed to initializer but with keys different of Symbol" do
-          lambda{ Methodic::Options::new 'titi' => 'tutu'}.should raise_error ArgumentError 
+          expect { Methodic::Options::new({'titi' => 'tutu'}) }.to raise_error(ArgumentError)
         end
-        it "should not raise ArgumentError if two arg is passed to initializer, second arg has a boolean value, must be object" do
-          lambda{ Methodic::Options::new({:name => 'Doe'},true) }.should_not raise_error ArgumentError
-        end
-
         it "should raise ArgumentError if more than two arg is passed to initializer" do
-          lambda{ Methodic::Options::new({:name => 'Doe'},{:surname => 'John'},true) }.should raise_error ArgumentError
+          expect { Methodic::Options::new({:name => 'Doe'},{:surname => 'John'},true) }.to raise_error(ArgumentError)
         end
-        
+
       end
 
     end
     context "Instance Attributs" do
       context "#classes R/W" do
-        it { $test_methodic_options.should respond_to("classes") }
-        it { $test_methodic_options.should respond_to("classes=") }
+        specify { expect($test_methodic_options).to respond_to("classes") }
+        specify { expect($test_methodic_options).to respond_to("classes=") }
 
-        it "should be true that #classes must return a Hash" do 
-          $test_methodic_options.classes.class.should eq(Hash)
+        it "should be true that #classes must return a Hash" do
+          expect($test_methodic_options.classes.class).to eq(Hash)
         end
         it "#classes[] affectation must be possible and #classes must respond this affectation" do
           $test_methodic_options.classes[:test] = String
-          $test_methodic_options.classes.should eq({:test => String})
+          expect($test_methodic_options.classes).to eq({:test => String})
         end
-        
+
       end
       context "#defaults R/W" do
-        it { $test_methodic_options.should respond_to("defaults") }
-        it { $test_methodic_options.should respond_to("defaults=") }
-        
+
+        specify { expect($test_methodic_options).to respond_to("defaults") }
+        specify { expect($test_methodic_options).to respond_to("defaults=") }
+
+        specify { expect($test_methodic_options).to respond_to("toto") }
+        specify { expect($test_methodic_options).to respond_to("toto=") }
+
         it "should be true that #defaults must return a Hash" do
-          $test_methodic_options.defaults.class.should eq(Hash)
+          expect($test_methodic_options.defaults.class).to eq(Hash)
         end
         it "#defaults[] affectation must be possible and #defaults must respond this affectation" do
           $test_methodic_options.defaults[:test] = "value"
-          $test_methodic_options.defaults.should eq({ :test => "value"})
+          expect($test_methodic_options.defaults).to eq({ :test => "value"})
         end
       end
 
       context "#formats R/W" do
-        it { $test_methodic_options.should respond_to("formats") }
-        it { $test_methodic_options.should respond_to("formats=") }
-        
+
+        specify { expect($test_methodic_options).to respond_to("formats") }
+        specify { expect($test_methodic_options).to respond_to("formats=") }
+
+
         it "should be true that #formats must return a Hash" do
-            $test_methodic_options.formats.class.should eq(Hash)
+            expect($test_methodic_options.formats.class).to eq(Hash)
         end
         it "#formats[] affectation must be possible and #formats must respond this affectation" do
-          $test_methodic_options.formats[:test] = '.*' 
-          $test_methodic_options.formats.should eq({ :test => '.*' })
+          $test_methodic_options.formats[:test] = '.*'
+          expect($test_methodic_options.formats).to eq({ :test => '.*' })
         end
       end
 
       context "#conditions R/W" do
-        it { $test_methodic_options.should respond_to("conditions") }
-        it { $test_methodic_options.should respond_to("conditions=") }
-        
+
+        specify { expect($test_methodic_options).to respond_to("conditions") }
+        specify { expect($test_methodic_options).to respond_to("conditions=") }
+
+
         it "should be true that #conditions must return a Hash" do
-            $test_methodic_options.conditions.class.should eq(Hash)
+            expect($test_methodic_options.conditions.class).to eq(Hash)
         end
+
         it "#formats[] affectation must be possible and #formats must respond this affectation" do
           aCond = Proc::new do |option| case option
                                          when 'Doe' then true
                                          else false
                                        end
           end
-          $test_methodic_options.conditions[:name] = aCond 
-          $test_methodic_options.conditions.should eq({ :name => aCond })
+          $test_methodic_options.conditions[:name] = aCond
+          expect($test_methodic_options.conditions).to eq({ :name => aCond })
         end
       end
 
       context "#mandatories R/W" do
-        it { $test_methodic_options.should respond_to("mandatories") }
-        it { $test_methodic_options.should respond_to("mandatories=") }
+        specify { expect($test_methodic_options).to respond_to("mandatories") }
+        specify { expect($test_methodic_options).to respond_to("mandatories=") }
 
         it "should be true that #mandatories must return a List < Array" do
-            $test_methodic_options.mandatories.class.should eq(List)
+            expect($test_methodic_options.mandatories.class).to eq(List)
         end
         it "#mandatories.push affectation must be possible and #mandatories must respond this affectation" do
           $test_methodic_options.mandatories.push :test
-          $test_methodic_options.mandatories.should eq([:test])
+          expect($test_methodic_options.mandatories).to eq([:test])
         end
         context "#mandatories.push" do
           it "should not duplicate entry"do
             $test_methodic_options.mandatories.push :test
             $test_methodic_options.mandatories.push :test
-            $test_methodic_options.mandatories.count(:test).should eq 1
+            expect($test_methodic_options.mandatories.count(:test)).to eq 1
           end
         end
       end
 
 
       context "#known R/W" do
-        it { $test_methodic_options.should respond_to("known") }
-        it { $test_methodic_options.should respond_to("known=") }
-        
+        specify { expect($test_methodic_options).to respond_to("known") }
+        specify { expect($test_methodic_options).to respond_to("known=") }
+
         it "should be true that #known must return a List < Array" do
-            $test_methodic_options.known.class.should eq(List)
+            expect($test_methodic_options.known.class).to eq(List)
         end
         it "#known.push affectation must be possible and #known must respond this affectation" do
           $test_methodic_options.known.push :test
-          $test_methodic_options.known.should include :test
+          expect($test_methodic_options.known).to include :test
         end
         context "#known.push" do
           it "should not duplicate entry" do
             $test_methodic_options.known.push :test
             $test_methodic_options.known.push :test
-            $test_methodic_options.known.count(:test).should eq 1
+            expect($test_methodic_options.known.count(:test)).to eq 1
           end
         end
       end
     end
     context "Instance methods" do
-      
+
 
 
 
       context "#options" do
-        it { $test_methodic_options.should respond_to("options") }
+        specify { expect($test_methodic_options).to respond_to("options") }
         it "should be true that #options must return a Array" do
-          $test_methodic_options.options.class.should eq(Array)
+          expect($test_methodic_options.options.class).to eq(Array)
         end
         it "should respond an Array of options keys" do
           $test_methodic_options.options.each do |item|
-            [:name,:surname].should include item
-          end 
+            expect([:name,:surname]).to include item
+          end
         end
       end
-      
+
       context "#specify_default_value" do
-        it { $test_methodic_options.should respond_to("specify_default_value") }
-        it { $test_methodic_options.should respond_to("specify_defaults_values") }    
+        specify { expect($test_methodic_options).to respond_to("specify_default_value") }
+        specify { expect($test_methodic_options).to respond_to("specify_defaults_values") }
+
         it "should merge default value hash record in defaults attribut" do
 
           $test_methodic_options.specify_default_value :test => 'value'
-          $test_methodic_options.defaults[:test].should eq 'value'
-          $test_methodic_options.defaults.count.should eq 1
+          expect($test_methodic_options.defaults[:test]).to eq 'value'
+          expect($test_methodic_options.defaults.count).to eq 1
         end
-        it "should redefine a new default value for a previous key" do 
+        it "should redefine a new default value for a previous key" do
           $test_methodic_options.specify_default_value :test => 'value'
-          $test_methodic_options.defaults[:test].should eq 'value'
+          expect($test_methodic_options.defaults[:test]).to eq 'value'
           $test_methodic_options.specify_default_value :test => 'newvalue'
-          $test_methodic_options.defaults[:test].should eq 'newvalue'
+          expect($test_methodic_options.defaults[:test]).to eq 'newvalue'
         end
       end
-      
-      context "#specify_class_of" do 
-        it { $test_methodic_options.should respond_to("specify_class_of") }
-        it { $test_methodic_options.should respond_to("specify_classes_of") }
+
+      context "#specify_class_of" do
+        specify { expect($test_methodic_options).to respond_to("specify_class_of") }
+        specify { expect($test_methodic_options).to respond_to("specify_classes_of") }
+
         it "should merge class hash record in classes attribut" do
 
           $test_methodic_options.specify_class_of :test => String
-          $test_methodic_options.classes[:test].should eq String
-          $test_methodic_options.classes.count.should eq 1
+          expect($test_methodic_options.classes[:test]).to eq String
+          expect($test_methodic_options.classes.count).to eq 1
         end
         it "should redefine a new class value for a previous key" do
           $test_methodic_options.specify_class_of :test => String
-          $test_methodic_options.classes[:test].should eq String
+          expect($test_methodic_options.classes[:test]).to eq String
           $test_methodic_options.specify_class_of :test => Integer
-          $test_methodic_options.classes[:test].should eq Integer
+          expect($test_methodic_options.classes[:test]).to eq Integer
 
         end
       end
@@ -207,17 +209,18 @@ describe Methodic do
 
 
       context "#specify_condition_for" do
-        it { $test_methodic_options.should respond_to("specify_condition_for") }
-        it { $test_methodic_options.should respond_to("specify_conditions_for") }
+        specify { expect($test_methodic_options).to respond_to("specify_condition_for") }
+        specify { expect($test_methodic_options).to respond_to("specify_conditions_for") }
+
         it "should merge condition hash record in conditions attribut" do
           aCond = Proc::new do |option| case option
                                          when "Doe" then true
                                          else false
                                        end
           end
-          $test_methodic_options.specify_condition_for :name => aCond 
-          $test_methodic_options.conditions[:name].should eq aCond
-          $test_methodic_options.conditions.count.should eq 1
+          $test_methodic_options.specify_condition_for :name => aCond
+          expect($test_methodic_options.conditions[:name]).to eq aCond
+          expect($test_methodic_options.conditions.count).to eq 1
         end
         it "should redefine a new class value for a previous key" do
           aCond = Proc::new do |option| case option
@@ -230,41 +233,42 @@ describe Methodic do
                                          else false
                                        end
           end
-          $test_methodic_options.specify_condition_for :name => aCond 
-          $test_methodic_options.conditions[:name].should eq aCond
-          $test_methodic_options.specify_condition_for :name => newCond 
-          $test_methodic_options.conditions[:name].should eq newCond
+          $test_methodic_options.specify_condition_for :name => aCond
+          expect($test_methodic_options.conditions[:name]).to eq aCond
+          $test_methodic_options.specify_condition_for :name => newCond
+          expect($test_methodic_options.conditions[:name]).to eq newCond
           $test_methodic_options.conditions = {}
         end
       end
 
       context "#specify_format_of" do
-        it { $test_methodic_options.should respond_to("specify_format_of") }
-        it { $test_methodic_options.should respond_to("specify_formats_of") }
+        specify { expect($test_methodic_options).to respond_to("specify_format_of") }
+        specify { expect($test_methodic_options).to respond_to("specify_formats_of") }
         it "should merge format hash record in formats attribut" do
           $test_methodic_options.formats = {}
           $test_methodic_options.specify_format_of :test => '.*'
-          $test_methodic_options.formats[:test].should eq '.*'
-          $test_methodic_options.formats.count.should eq 1
+          expect($test_methodic_options.formats[:test]).to eq '.*'
+          expect($test_methodic_options.formats.count).to eq 1
         end
         it "should redefine a new format value for a previous format key" do
           $test_methodic_options.specify_format_of :test => '.*'
-          $test_methodic_options.formats[:test].should eq '.*'
+          expect($test_methodic_options.formats[:test]).to eq '.*'
           $test_methodic_options.specify_format_of :test => '\d*'
-          $test_methodic_options.formats[:test].should eq '\d*' 
+          expect($test_methodic_options.formats[:test]).to eq '\d*'
         end
       end
 
       context "#specify_presence_of" do
-        it { $test_methodic_options.should respond_to("specify_presence_of") }
-        it { $test_methodic_options.should respond_to("specify_presences_of") }
+        specify { expect($test_methodic_options).to respond_to("specify_presence_of") }
+        specify { expect($test_methodic_options).to respond_to("specify_presences_of") }
+
         it "should merge presence Array record in mandatories attribut" do
           $test_methodic_options.specify_presence_of :test
-          $test_methodic_options.mandatories.should include(:test)
-          $test_methodic_options.mandatories.count.should eq 1
+          expect($test_methodic_options.mandatories).to include(:test)
+          expect($test_methodic_options.mandatories.count).to eq 1
           $test_methodic_options.specify_presence_of :test
-          $test_methodic_options.mandatories.should include(:test)
-          $test_methodic_options.mandatories.count.should eq 1
+          expect($test_methodic_options.mandatories).to include(:test)
+          expect($test_methodic_options.mandatories.count).to eq 1
         end
         it "should be possible to give arguments list of symbols" do
           $test_methodic_options.specify_presences_of :test2, :test3, :test4
@@ -273,141 +277,87 @@ describe Methodic do
       end
 
       context "#specify_known_option" do
-        it { $test_methodic_options.should respond_to("specify_known_option") }
-        it { $test_methodic_options.should respond_to("specify_known_options") }
+        specify { expect($test_methodic_options).to respond_to("specify_known_option") }
+        specify { expect($test_methodic_options).to respond_to("specify_known_options") }
+
         it "should merge known Array record in known attribut" do
           $test_methodic_options.specify_known_option :test
-          $test_methodic_options.known.should include(:test)
-          $test_methodic_options.known.count.should eq 1
+          expect($test_methodic_options.known).to include(:test)
+          expect($test_methodic_options.known.count).to eq 1
           $test_methodic_options.specify_known_option :test
-          $test_methodic_options.known.should include(:test)
-          $test_methodic_options.known.count.should eq 1
+          expect($test_methodic_options.known).to include(:test)
+          expect($test_methodic_options.known.count).to eq 1
         end
         it "should be possible to give arguments list of symbols" do
           $test_methodic_options.specify_known_options :test2, :test3, :test4
           $test_methodic_options.specify_known_options [ :test5, :test6 ], :test7
-          
+
         end
       end
 
       context "#validate" do
-        
-        it { $test_methodic_options.should respond_to("validate") }
-        it { $test_methodic_options.should respond_to("validate!") }
-        
-        
-        context "1/ validate known options" do
-          context "@validate_known_options = false (default)" do            
-            it "should not raise ArgumentError if mandatories is not fully include in the known options list" do
-              $test_methodic_options.known = []
-              $test_methodic_options.specify_presences_of [ :name, :surname]
-              $test_methodic_options.specify_known_options [ :surname]
-              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-            end
-            it "should not raise ArgumentError if an option in options list not in the known options list" do
-              $test_methodic_options.known = []
-              $test_methodic_options.specify_known_options [ :surname ]
-              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-            end
-            it "should not raise if all given options in options list is in known options " do
-              $test_methodic_options.known = []
-              $test_methodic_options.specify_known_options [ :name, :surname, :optional ]
-              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-            end
-            it "should not raise ArgumentError if formats made a reference to an unknown options" do
-              $test_methodic_options.known = []
-              $test_methodic_options.specify_format_of :nickname => /.*/
-              $test_methodic_options.specify_known_options [ :surname, :name ]
-              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-            end
-            it "should not raise ArgumentError if classes made a reference to an unknown options" do
-              $test_methodic_options.known = []
-              $test_methodic_options[:nickname] = 'Jeedoe'
-              $test_methodic_options.specify_class_of :nickname => String
-              $test_methodic_options.specify_known_options [ :surname, :name ]
-              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-            end
-            it "should not raise ArgumentError if default made a reference to an unknown options" do
-              $test_methodic_options.known = []
-              $test_methodic_options.specify_default_value :nickname => 'Jeedoe'
-              $test_methodic_options.specify_known_options [ :surname, :name ]
-              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-            end
 
-          end
-          context "@validate_known_options = true" do            
+        specify { expect($test_methodic_options).to respond_to("validate") }
+        specify { expect($test_methodic_options).to respond_to("validate!") }
+
+
+        context "1/ validate known options" do
+          context "@validate_known_options = true" do
             it "should raise ArgumentError if mandatories is not fully include in the known options list" do
               $test_methodic_options_with_known_options.known = []
               $test_methodic_options_with_known_options.specify_presences_of [ :name, :surname ]
               $test_methodic_options_with_known_options.specify_known_options [ :surname ]
-              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+              expect { $test_methodic_options_with_known_options.validate! }.to raise_error(ArgumentError)
             end
             it "should raise ArgumentError if an option in options list not in the known options list" do
               $test_methodic_options_with_known_options.known = []
               $test_methodic_options_with_known_options.specify_known_options [ :surname]
-              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
-            end
-            it "should not raise if all given options in options list is in known options " do
-              $test_methodic_options_with_known_options.known = []
-              $test_methodic_options_with_known_options.specify_known_options [ :name, :surname,:optional]
-              lambda{$test_methodic_options_with_known_options.validate!}.should_not raise_error ArgumentError
+              expect { $test_methodic_options_with_known_options.validate! }.to raise_error(ArgumentError)
             end
             it "should raise ArgumentError if formats made a reference to an unknown options" do
               $test_methodic_options_with_known_options.known = []
               $test_methodic_options_with_known_options.specify_format_of :nickname => /.*/
               $test_methodic_options_with_known_options.specify_known_options [ :surname, :name ]
-              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+              expect { $test_methodic_options_with_known_options.validate! }.to raise_error(ArgumentError)
             end
             it "should raise ArgumentError if classes made a reference to an unknown options" do
               $test_methodic_options_with_known_options.known = []
               $test_methodic_options_with_known_options[:nickname] = 'Jeedoe'
               $test_methodic_options_with_known_options.specify_class_of :nickname => String
               $test_methodic_options_with_known_options.specify_known_options [ :surname, :name ]
-              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+              expect { $test_methodic_options_with_known_options.validate! }.to raise_error(ArgumentError)
             end
             it "should raise ArgumentError if default made a reference to an unknown options" do
               $test_methodic_options_with_known_options.known = []
               $test_methodic_options_with_known_options.specify_default_value :nickname => 'Jeedoe'
               $test_methodic_options_with_known_options.specify_known_options [ :surname, :name ]
-              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+              expect { $test_methodic_options_with_known_options.validate! }.to raise_error(ArgumentError)
             end
-            
+
           end
-          
+
         end
 
         context "2/ validate classes" do
-          it "should raise ArgumentError if an options don't match a class definition" do 
+          it "should raise ArgumentError if an options don't match a class definition" do
             $test_methodic_options.specify_classes_of :name => Integer, :surname => String
-            lambda{$test_methodic_options.validate!}.should raise_error ArgumentError 
+            expect { $test_methodic_options.validate! }.to raise_error(ArgumentError)
 
           end
-          it "should not raise if options match class definition" do 
-            $test_methodic_options.specify_classes_of :name => String, :surname => String
-            lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError 
-          end
         end
         context "3/ validate mandatories" do
           it "should raise ArgumentError if a mandatory option not in options list" do
             $test_methodic_options.specify_presences_of [ :name , :surname, :nickname, :age ]
-            lambda{$test_methodic_options.validate!}.should raise_error ArgumentError
+            expect { $test_methodic_options.validate! }.to raise_error(ArgumentError)
 
           end
-          it "should not raise if mandatory options and options list match" do
-            $test_methodic_options.specify_presences_of [ :name , :surname ]
-            lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-          end
         end
         context "4/ validate formats" do
           it "should raise ArgumentError if an option in options list not have the good registered formats" do
             $test_methodic_options.specify_formats_of :name => /.*/, :surname => /toto.*/
-            lambda{$test_methodic_options.validate!}.should raise_error ArgumentError
+            expect { $test_methodic_options.validate! }.to raise_error(ArgumentError)
 
           end
-          it "should not raise if all options in options list match formats definitions " do
-            $test_methodic_options.specify_formats_of :name => /.*/, :surname => /.*/
-            lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-          end
         end
         context "5/ validate conditions" do
           it "should raise ArgumentError if an option in options list not validate a registered condition" do
@@ -418,33 +368,24 @@ describe Methodic do
                                           end
             end
             $test_methodic_options.specify_condition_for :name => aCond
-            lambda{$test_methodic_options.validate!}.should raise_error ArgumentError
+            expect { $test_methodic_options.validate! }.to raise_error(ArgumentError)
 
           end
-          it "should not raise if all options in options list match formats definitions " do
-           $test_methodic_options.conditions = {}
-            aCond = Proc::new do |option| case option
-                                          when 'Doe' then true
-                                          else false
-                                          end
-            end
-            $test_methodic_options.specify_condition_for :name => aCond
-            lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
-          end
         end
 
 
 
-      end 
+      end
       context "#merge_with_defaults" do
-        it { $test_methodic_options.should respond_to("merge_with_defaults") }
-        it { $test_methodic_options.should respond_to("merge") }
-        it "should merge defaults values and don't override with options" do 
+        specify { expect($test_methodic_options).to respond_to("merge_with_defaults") }
+        specify { expect($test_methodic_options).to respond_to("merge") }
+
+        it "should merge defaults values and don't override with options" do
           $test_methodic_options.specify_defaults_values :name => 'Smith', :surname => 'Paul', :nickname => 'Jeedoe'
           $test_methodic_options.merge_with_defaults
-          $test_methodic_options[:name].should eq "Doe"
-          $test_methodic_options[:surname].should eq "John"
-          $test_methodic_options[:nickname].should eq "Jeedoe"
+          expect($test_methodic_options[:name]).to eq "Doe"
+          expect($test_methodic_options[:surname]).to eq "John"
+          expect($test_methodic_options[:nickname]).to eq "Jeedoe"
 
         end
       end
@@ -452,8 +393,8 @@ describe Methodic do
   end
   context "Methodic::get_options" do
     it "should return a Methodic::Options Object" do
-      Methodic::get_options({:name => 'Doe', :surname => 'John'}).should be_an_instance_of Methodic::Options
+      expect(Methodic::get_options({:name => 'Doe', :surname => 'John'})).to be_an_instance_of Methodic::Options
     end
   end
-  
-end  
+
+end