rspec-i18n 1.1.0 → 1.2.0

data/spec/spec-i18n/matchers/eql_spec.rb

@@ -5,19 +5,17 @@ module Spec
     describe "eql" do
       
       before(:each) do
-        @expected_matcher = {'matchers' => {'eql' => 'igl'}}
-        portuguese_language(@expected_matcher)
+        @keywords = {'matchers' => {'eql' => 'igl'}}
+        stub_language!("pt", @keywords)
         Spec::Matchers.register_all_matchers
       end
       
       it "should have eql matchers translated" do
-        eql_word = @expected_matcher['matchers']['eql']
-        1.methods.should be_include(eql_word)
+        methods.to_symbols.should include(:igl)
       end
       
       it "should have eql? matchers translated" do
-        eql_word = @expected_matcher['matchers']['eql'] + '?'
-        1.methods.should be_include(eql_word)
+        methods.to_symbols.should include(:igl?)
       end
       
       it "should match when actual.eql?(expected)" do

data/spec/spec-i18n/matchers/equal_spec.rb

@@ -2,25 +2,46 @@ require "spec_helper"
 
 module Spec
   module Matchers
+    
     describe 'equal' do
+      
       before(:each) do
-        @expected_matcher = {'matchers' => {'equal' => 'igual|igual_a'}}
-        portuguese_language(@expected_matcher)
+        @keywords = {'matchers' => {'equal' => 'igual|igual_a'}}
+        stub_language!("pt", @keywords)
         Spec::Matchers.register_all_matchers
       end
       
-      it 'should register the methods for the value equal matcher' do
-        values = @expected_matcher['matchers']['equal'].split('|') 
-        values.each { |method_name| Object.instance_methods.should be_include(method_name) }
+      it 'should translated the methods for the value equal matcher' do
+        [:igual, :igual_a].each do |translated_matcher|
+          methods.to_symbols.should include(translated_matcher)
+        end
+      end
+      
+      it "should translated the methods with '?' char" do
+        [:igual?, :igual_a?].each do |translated_method|
+          methods.to_symbols.should include(translated_method)
+        end
       end
       
       it "should match when actual.equal?(expected)" do
         1.should igual(1)
       end
-
+      
+      it "should be true when actual.equal?(expected) with ?" do
+        1.igual?(1).should be_true
+        1.should be_igual(1)
+      end
+      
       it "should not match when !actual.equal?(expected)" do
-        1.should_not igual_a("1")
+        1.should_not be_igual_a("1")
       end
+      
+      it "should not match when !actual.equal?(expected) with ?" do
+        1.igual_a?(1).should be_true
+        1.should be_igual_a(1)
+      end
+      
     end
+    
   end
 end

data/spec/spec-i18n/matchers/exist_spec.rb

@@ -17,17 +17,16 @@ module Spec
     describe "exist matcher" do
       
       before(:each) do
-        @expected_matcher = {'matchers' => {'exist' => 'existir'}}
-        portuguese_language(@expected_matcher)
+        @keywords = {'matchers' => {'exist' => 'existir|existe'}}
+        stub_language!("pt", @keywords)
         Spec::Matchers.register_all_matchers
         @real = Substance.new true, 'something real'
         @imaginary = Substance.new false, 'something imaginary'
       end
       
       it 'should register the exist method translated' do
-        values = @expected_matcher['matchers']['exist'].split('|')
-        values.each do |value_method|
-          Object.instance_methods.should be_include(value_method)
+        [:existir, :existe].each do |translated_matcher|
+          methods.to_symbols.should include(translated_matcher)
         end
       end
       

data/spec/spec-i18n/matchers/have_spec.rb

@@ -7,7 +7,7 @@ describe 'have, have_exactly, have_at_least and have_at_most matcher' do
                 'have_exactly' => 'ter_exatamente', 
                 'have_at_most' => 'ter_no_maximo'}
     @expected_matcher = {'matchers' => matchers}
-    portuguese_language(@expected_matcher)
+    stub_language!("pt", @expected_matcher)
     Spec::Matchers.register_all_matchers
   end
   

data/spec/spec-i18n/matchers/include_spec.rb

@@ -1,19 +1,17 @@
 require 'spec_helper'
 
 describe "should include(expected)" do
+  
   before(:each) do
-    @expected_matcher = {'matchers' => { 'include' => 'incluir'} }
-    portuguese_language(@expected_matcher)
-    Spec::Matchers.register_all_matchers
+    @keywords = { 'matchers' => {'include' => 'incluir|incluso'} }
+    stub_language!("pt", @keywords)
+    Spec::Matchers.translate_basic_matchers
   end
   
   it "should translated the include matcher" do
-    values = @expected_matcher['matchers']['include'].split('|')
-    
-    values.each do |value_method|
-      Object.instance_methods.should be_include(value_method)
+    ["incluir", "incluso"].each do |value_method|
+      methods.all_to_symbols.should be_include(value_method.to_sym)
     end
-    
   end
   
   it "should pass if target includes expected" do

data/spec/spec-i18n/matchers/match_spec.rb

@@ -2,15 +2,14 @@ require 'spec_helper'
 
 describe "should match(expected)" do
   before(:each) do
-    @expected_matcher = {'matchers' => { 'match' => 'corresponder'} }
-    portuguese_language(@expected_matcher)
+    @expected_matcher = {'matchers' => { 'match' => 'corresponder|corresponde'} }
+    stub_language!("pt", @expected_matcher)
     Spec::Matchers.register_all_matchers
   end
   
   it "should translated the include matcher" do
-    values = @expected_matcher['matchers']['match'].split('|')
-    values.each do |value_method|
-      Object.instance_methods.should be_include(value_method)
+    [:corresponder, :corresponde].each do |translated_matcher|
+      methods.to_symbols.should include(translated_matcher)
     end
   end
   

data/spec/spec-i18n/matchers/raise_error_spec.rb

@@ -3,14 +3,15 @@ require 'spec_helper'
 describe "should raise_error" do
   
   before(:each) do
-    @expected_matcher = {'matchers' => {'raise_error' => 'mostrar_erro'}}
-    portuguese_language(@expected_matcher)
+    @expected_matcher = {'matchers' => {'raise_error' => 'mostrar_erro|mostrar_excessao'}}
+    stub_language!("pt", @expected_matcher)
     Spec::Matchers.register_all_matchers
   end
   
   it 'should register the methods for the value equal matcher' do
-    values = @expected_matcher['matchers']['raise_error'].split('|') 
-    values.each { |method_name| Object.instance_methods.should be_include(method_name) }
+    [:mostrar_erro, :mostrar_excessao].each do |translated_matcher|
+      methods.to_symbols.should include(translated_matcher)
+    end
   end
   
   it "should pass if anything is raised" do

data/spec/spec-i18n/matchers/satisfy_spec.rb

@@ -3,15 +3,14 @@ require 'spec_helper'
 describe "should satisfy { block }" do
   
   before(:each) do
-    @expected_matcher = { 'matchers' => { 'satisfy' => 'satisfazer'} }
-    portuguese_language(@expected_matcher)
+    @keywords = { 'matchers' => { 'satisfy' => 'satisfazer|satisfaz'} }
+    stub_language!("pt", @keywords)
     Spec::Matchers.register_all_matchers
   end
   
   it 'should trasnlate the satisfy matcher' do
-    values = @expected_matcher['matchers']['satisfy'].split('|')
-    values.each do |value_method|
-      Object.instance_methods.should be_include(value_method)
+    [:satisfazer, :satisfazer].each do |translated_matcher|
+      methods.to_symbols.should include(translated_matcher)
     end
   end
   

data/spec/spec-i18n/parser/natural_language_spec.rb

@@ -5,18 +5,14 @@ module SpecI18n
     describe NaturalLanguage do
 
       before(:each) do
-        @pt = NaturalLanguage.get('pt')
-        @es = NaturalLanguage.get('es')
-        @en = NaturalLanguage.get('en')
+        @pt = NaturalLanguage.new('pt')
+        @es = NaturalLanguage.new('es')
+        @en = NaturalLanguage.new('en')
+        @germany = NaturalLanguage.new('de')
+        @portuguese = @pt
+        @spanish = @es
       end
-
-      %w(describe before after it should name native).each do |keyword|
-         it "should have the #{keyword} keyword" do
-           portuguese_keys = @pt.keywords.keys          
-           portuguese_keys.should include(keyword)
-         end
-       end
-       
+      
       context "get languages" do
         
         it "should get the default language" do
@@ -27,7 +23,13 @@ module SpecI18n
           language = "non_existing"
           lambda {  
             NaturalLanguage.new(language) 
-          }.should raise_error(LanguageNotFound, "Language #{language} Not Supported")
+          }.should raise_exception(LanguageNotFound, "Language #{language} Not Supported")
+        end
+        
+        it "should raise a error for the NIL language" do
+          lambda {
+            NaturalLanguage.new(nil)
+          }.should raise_exception(LanguageNilNotFound, "Language -> nil Not Found")
         end
 
       end
@@ -39,19 +41,29 @@ module SpecI18n
         end
         
         it "should return true for the incomplete language" do
-          @pt.stub!(:keywords).and_return({ :name => []})
+          @pt.stub!(:keywords).and_return({})
           @pt.incomplete?.should be_true
         end
-        
+                
       end
       
       context "of dsl keywords" do
       
         it "should return the describe dsl keyword" do
-          lang = { "describe" => "descreva", :before => "antes" }
-          @pt.should_receive(:keywords).at_least(:once).and_return(lang)
-          @pt.dsl_keywords.should == { "describe" => [ lang["describe"] ] }
+          stub_keywords!(@portuguese, { "describe" => "descreva", :before => "antes" })
+          @portuguese.dsl_keywords.should == { "describe" => [ 'descreva' ] }
+        end
+        
+        it "should return a empty Array whe dont have keywords" do
+          stub_keywords!(@portuguese, {})
+          @portuguese.dsl_keywords.should == { 'describe' => [] }
+        end
+        
+        it "should return a empty Array when describe keyword is nil" do
+          stub_keywords!(@portuguese, { 'describe' => nil})
+          @portuguese.dsl_keywords.should == {'describe' => []}
         end
+        
       end
 
       context "of expectations keywords" do
@@ -67,32 +79,33 @@ module SpecI18n
         end
         
         it "should return the expectation keywords of the current language" do
-          keywords = { "should" => ["deberia"], "should_not" => ["no_debe"]}
-          @es.expectation_keywords.should == keywords
+          keywords = { "should" => "deberia", "should_not" => "no_debe"}
+          @es.should_receive(:keywords).at_least(:once).and_return(keywords)
+          @es.expectation_keywords.should == { 'should' => ['deberia'], 'should_not' => ['no_debe']}
         end
+        
       end
       
-      context "of before and after keywords" do
-        
-        before(:each) do
-          @language = { "before" => "before", "after" => "after"}
-        end
-        
+      describe "#before_and_after_keywords" do
+                
         it "should return the hooks for the current language" do
-          @en.should_receive(:keywords).at_least(:once).and_return(@language)
-          keywords = { "before" => ["before"], "after" => ["after"]}
-          @en.before_and_after_keywords.should == keywords
+          stub_keywords!(@en, { "before" => "before", "after" => "after"})
+          @en.before_and_after_keywords.should == { "before" => ["before"], "after" => ["after"]}
         end
         
         it "should return the hooks for the language" do
-          language = {"before" => "antes", "after" => "depois"}
-          keywords = { "before" => ["antes"], "after" => ["depois"]}
-          @pt.stub!(:keywords).and_return(language)
-          @pt.before_and_after_keywords.should == keywords
+          stub_keywords!(@portuguese, {"before" => "antes", "after" => "depois"})
+          @portuguese.before_and_after_keywords.should == { "before" => ["antes"], "after" => ["depois"]}
+        end
+        
+        it "should not raise a error when not have before and after keyword" do
+          stub_keywords!(@portuguese, {})
+          @portuguese.before_and_after_keywords.should == {'before' => [], 'after' => []}
         end
+        
       end
       
-      context "of hooks keywords" do
+      context "#hooks" do
         
         before(:each) do
           @lang = { "hooks" => {"each" => "de_cada|de_cada_exemplo", 
@@ -104,11 +117,56 @@ module SpecI18n
         end
         
         it "should return the hooks parameters for the current language" do
-          @pt.stub!(:keywords).and_return(@lang)
-          @pt.hooks_params_keywords.should == @keywords                       
+          stub_keywords!(@portuguese, @lang)
+          @portuguese.hooks_params_keywords.should == @keywords                       
+        end
+        
+        it "should return something when not have hooks" do
+          stub_keywords!(@portuguese, {})
+          @portuguese.hooks_params_keywords.should == {}
         end
+        
       end
       
+      describe "#hooks_permutation" do
+        
+        it "should return a Hash of possibilities" do
+          stub_keywords!(@portuguese, {'before' => 'antes', 'hooks' => {'each' => 'cada|de_cada'}})
+          @portuguese.hooks_permutation.should include({ 'before(:each)' => ['antes(:cada)', 'antes(:de_cada)']})
+        end
+        
+        it "should return a before in Hash keys" do
+          stub_keywords!(@portuguese, {'before' => 'antes', 'hooks' => {'each' => 'de_cada' , 'all' => 'de_todos'}})
+          @portuguese.hooks_permutation.should include({ 'before(:each)' => ['antes(:de_cada)'], 'before(:all)' => ['antes(:de_todos)'] })
+        end
+        
+        it "should return a after in Hash" do
+          stub_keywords!(@portuguese, { 'after' => 'depois', 'hooks' => {'each' => 'cada'} })
+          @portuguese.hooks_permutation.should include({ 'after(:each)' => ['depois(:cada)'] })
+        end
+        
+        it "should return a empty Hash when not have hooks" do
+          stub_keywords!(@portuguese, {'after' => 'depois', 'before' => 'antes'})
+          @portuguese.hooks_permutation.should == {}
+        end
+        
+        it "should return a various keys for varius before words" do
+          stub_keywords!(@portuguese, {'after' => 'depois|ah_depois', 'hooks' => {'each' => 'cada'}})
+          @portuguese.hooks_permutation.should include({'after(:each)' => ['depois(:cada)', 'ah_depois(:cada)']})
+        end
+        
+        it "should return a empty Hash when not have before and after keywords" do
+          stub_keywords!(@portuguese, {})
+          @portuguese.hooks_permutation.should == {}
+        end
+        
+        it "should return a empty Hash when have nil values for before and after keywords" do
+          stub_keywords!(@portuguese, {'before' => nil, 'after' => nil})
+          @portuguese.hooks_permutation.should == {}
+        end
+        
+      end
+            
       context "of example group keywords" do
         
         before(:each) do
@@ -131,12 +189,12 @@ module SpecI18n
         end
 
         it 'should return the subject keywords' do
-          @pt.stub!(:keywords).and_return(@keywords)
+          @pt.should_receive(:keywords).at_least(:once).and_return(@keywords)
           @pt.subject_keywords.should == {'subject' => ["assunto", "tema"]}
         end
 
         it 'should return the subject keywords for spanish language' do
-          @spanish_keywords.stub!(:keywords).and_return(@spanish_keywords)
+          @es.should_receive(:keywords).at_least(:once).and_return(@spanish_keywords)
           @es.subject_keywords.should == { 'subject' => ['asunto', 'tema']}
         end
       end
@@ -159,12 +217,137 @@ module SpecI18n
         end
       end
       
+      context 'matchers' do
+        
+        before(:each) do
+          @keywords = { "matchers" => { "be" => "ser", 
+            "include" => "incluir|incluso", "be_close" => nil}}
+        end
+        
+        it "should return an hash of matchers" do
+          stub_keywords!(@pt, @keywords)
+          @pt.matchers.should == @keywords["matchers"]
+        end
+        
+        it "should return an empty hash for non exist matchers" do
+          stub_keywords!(@portuguese, {'name' => 'Portuguese'})
+          @portuguese.matchers.should eql({})
+        end
+        
+        it "should find a matcher that exist" do
+          stub_keywords!(@pt, @keywords)
+          @pt.find_matcher(:include).should == { "include" => ["incluir", "incluso"]}
+        end
+        
+        it "should return a hash with empty value for the empty value of matcher" do
+          stub_keywords!(@pt, @keywords)
+          @pt.find_matcher(:be_close).should == {"be_close" => []}
+        end
+        
+      end
+      
+      context 'hooks' do
+        
+        it "should return a empty Hash when not have hooks" do
+          stub_keywords!(@portuguese, {'name' => 'Portuguese'})
+          @portuguese.hooks.should eql({})
+        end
+        
+        it "should return all the hooks" do
+          stub_keywords!(@portuguese, {'hooks' => { 'each' => 'cada'}})
+          @portuguese.hooks.should eql({'each' => 'cada'})
+        end
+        
+        it "should return the hooks with | separator in a string" do
+          stub_keywords!(@portuguese, {'hooks' => {'all' => 'todos|de_todos'}})
+          @portuguese.hooks.should eql({'all' => 'todos|de_todos'})
+        end
+        
+      end
+      
+      context 'shared examples keywords' do
+        
+        before(:each) do
+          @keywords = { 'shared_examples_for' => 'exemplos_distribuidos|distribuido',
+          'it_should_behave_like' => 'deve_se_comportar_como|deve_se_comportar',
+          'share_as' => 'distribua|distribua_como' }
+          stub_keywords!(@pt, @keywords)
+        end
+        
+        it "should return the words for shared examples for separated by '|'" do
+          expected = {"shared_examples_for" => ['exemplos_distribuidos', 'distribuido']}
+          @pt.shared_examples_for_keywords.should ==(expected)
+        end
+        
+        it "should return the words for it should behave like keyword" do
+          expected = {"it_should_behave_like" => ['deve_se_comportar_como', 'deve_se_comportar']}
+          @pt.it_should_behave_like_keywords.should ==(expected)
+        end
+        
+        it "should return the words for shares as keyword" do
+          expected = { 'share_as' => ['distribua', 'distribua_como']}
+          @pt.share_as_keywords.should == expected
+        end
+        
+      end
+      
+      context 'when pending keywords' do
+        
+        it "should return the pending keywords" do
+          @keywords = { 'pending' => 'pendente|pendencia' }
+          stub_keywords!(@pt, @keywords)
+          @pt.pending_keywords.should == { 'pending' => ['pendente', 'pendencia']}
+        end
+        
+        it "should return the pending keywords for languages" do
+          @keywords = { 'pending' => 'spec_pendente'}
+          stub_keywords!(@es, @keywords)
+          @es.pending_keywords.should == { 'pending' => ['spec_pendente']}
+        end
+        
+      end
+      
+      context "be keyword" do
+        
+        it "should return an array with values of be word" do
+          stub_keywords!(@pt, { "matchers" => { "be" => "ser|estar" }})
+          @pt.keywords_of_be_word.should == ["ser", "estar"]
+        end
+        
+        it "should return a empty array for matchers withou be keyword" do
+          stub_keywords!(@portuguese, {'matchers' => { 'eql' => 'igl'}})
+          @portuguese.keywords_of_be_word.should == []
+        end
+        
+        it "should return a empty array for non found keyword" do
+          stub_keywords!(@pt, {})
+          @pt.keywords_of_be_word.should == []
+        end
+        
+      end
+      
       context "splitting the keys" do
+        
         it "should raise no found key" do
           lambda {
-            @pt.spec_keywords("no_found")
+            @pt.spec_keywords("no_found")            
+          }.should_not raise_exception(RuntimeError)
+        end
+        
+        it "should raise exception for not found key" do
+          lambda {
             @pt.spec_keywords("Oh_MY_this_words_is_not_found!")
-          }.should raise_error(RuntimeError)
+          }.should_not raise_exception(RuntimeError)
+        end
+        
+        it "should return a Hash of Array values" do
+          @portuguese.spec_keywords('something_that_dont_exist').should == {'something_that_dont_exist' => []}
+        end
+        
+        it "should not raise error for key found but key is nil" do
+          lang = { 'describe' => nil}
+          @pt.stub!(:keywords).and_return(lang)
+          @pt.spec_keywords("describe").should == { 'describe' => []}
         end
 
         it "should split correctly the keys" do
@@ -174,33 +357,212 @@ module SpecI18n
         end
       end
     
-      context "be_true, be_false and be_nil" do
+      describe "when word be" do
         
-        it "should return all the be_true possibilities" do
-          lang = { "matchers" => { 'be' => 'ser|outro_ser', 'true_word' => 'verdade|verdadeiro'}}
-          expected_words = ["ser_verdadeiro", "ser_verdade", "outro_ser_verdade","outro_ser_verdadeiro"]
-          @pt.stub!(:keywords).and_return(lang)
-          expected_words.each do |expected|
-            @pt.word_be("true").should include expected
+        context 'when be true keyword' do
+                    
+          it "should return all the be_true possibilities" do
+            keywords = { "matchers" => { 'be' => 'ser|outro_ser', 'true_word' => 'verdade|verdadeiro'} }
+            stub_keywords!(@pt, keywords)
+            @pt.word_be("true").should eql(["ser_verdade", "ser_verdadeiro", "outro_ser_verdade","outro_ser_verdadeiro"])
+          end
+          
+          it "should return all the be_true possibilities inverted" do
+            keywords = { 'matchers' => { 'be' => 'sein', 'true_word' => 'wahr*' }}
+            stub_keywords!(@germany, keywords)
+            @germany.word_be('true').should eql(['wahr_sein'])
+          end
+          
+          it "should return a empty array for the non keyword" do
+            keywords = {}
+            stub_keywords!(@germany, keywords)
+            @germany.word_be('true').should eql []
+          end
+          
+          it "should return a empty array for the nil be keyword" do
+            keywords = { 'matchers' => { 'be' => nil, 'true' => nil }}
+            stub_keywords!(@germany, keywords)
+            @germany.word_be('true').should eql []
           end
+          
+          it "should return a empty array for the nil true keyword" do
+            keywords = { 'matchers' => { 'be' => 'sein', 'true' => nil}}
+            stub_keywords!(@germany, keywords)
+            @germany.word_be('true').should eql []
+          end
+          
         end
         
-        it "should return all the be_nil possibilities" do
-          lang = { "matchers" => { 'be' => 'ser|outro_ser', 'nil_word' => 'nulo|muito_nulo'}}
-          expected_words = ["ser_nulo", "ser_muito_nulo"]
-          @pt.stub!(:keywords).and_return(lang)
-          expected_words.each do |expected|
-            @pt.word_be("nil").should include expected
+        context 'when be nil keyword' do
+          
+          it "should return all the be_nil possibilities" do
+            @pt_keywords = { "matchers" => { 'be' => 'ser|outro_ser', 'nil_word' => 'nulo|muito_nulo'}}
+            stub_keywords!(@pt, @pt_keywords)
+            @pt.word_be("nil").should eql(["ser_nulo", "ser_muito_nulo", "outro_ser_nulo", "outro_ser_muito_nulo"])
+          end
+          
+          it "should return all the be_nil possibilities for the inverted keyword" do
+            keywords = { 'matchers' => { 'be' => 'sein', 'nil_word' => "null*" }}
+            stub_keywords!(@germany, keywords)
+            @germany.word_be('nil').should eql(['null_sein'])
+          end
+          
+          it "should return a empty array for the non matchers keyword" do
+            keywords = {}
+            stub_keywords!(@es, keywords)
+            @es.word_be('nil').should eql []
+          end
+          
+          it "should return a empty array for the non be keyword" do
+            keywords = { 'matchers' => { 'be' => nil, 'nil' => nil }}
+            stub_keywords!(@en, keywords)
+            @en.word_be('nil').should eql []
           end
+          
+          it "should return a empty array for the non nil keyword" do
+            keywords = { 'matchers' => { 'be' => 'ser', 'nil' => nil }}
+            stub_keywords!(@pt, keywords)
+            @pt.word_be('nil').should eql []
+          end
+
         end
         
-        it "should return all the be_false possibilities" do
-          lang = { "matchers" => { 'be' => 'ser|outro_ser', 'false_word' => 'falso|muito_falso'}}
-          expected_words = ["ser_falso", "ser_muito_falso"]
-          @pt.stub!(:keywords).and_return(lang)
-          expected_words.each do |expected|
-            @pt.word_be("false").should include expected
+        context 'when be false keyword' do
+          
+          it "should return all the be_false possibilities" do
+            @pt_keywords = { 'matchers' => { 'be' => 'ser|outro_ser', 'false_word' => 'falso|muito_falso'}}
+            stub_keywords!(@pt, @pt_keywords)
+            @pt.word_be("false").should eql(["ser_falso", "ser_muito_falso", "outro_ser_falso", "outro_ser_muito_falso"])
+          end
+          
+          it "should return all the be_false possibilities for the inverted keyword" do
+            keywords = { 'matchers' => { 'be' => 'sein', 'false_word' => 'falsch*' }}
+            stub_keywords!(@germany, keywords)
+            @germany.word_be('false').should eql(['falsch_sein'])
+          end
+          
+          it 'should return a empty array for the non false keyword' do
+            keywords = {}
+            stub_keywords!(@en, keywords)
+            @en.word_be('false').should eql []
           end
+          
+          it 'should return a empty array for the non false keyword' do
+            keywords = { 'matchers' => { 'be' => 'ser', 'false' => nil }}
+            stub_keywords!(@es, keywords)
+            @es.word_be('false').should eql []
+          end
+          
+        end
+        
+        context 'when be empty keyword' do
+          
+          it "should return all the be empty possibilities" do
+            keywords = { 'matchers' => { 'be' => 'ser', 'empty_word' => 'vazio|muito_vazio'}}
+            stub_keywords!(@portuguese, keywords)
+            @portuguese.word_be('empty').should eql(['ser_vazio', 'ser_muito_vazio'])
+          end
+          
+          it "should return the inverted be_empty keyword for keywords with '*' char" do
+            keywords = {'matchers' => { 'be' => 'sein', 'empty_word' => 'leer*'}}
+            stub_keywords!(@germany, keywords)
+            @germany.word_be('empty').should eql(['leer_sein'])
+          end
+          
+        end
+        
+      end
+    
+      context 'when invert_order_of_object_and_verbs?' do
+        
+        it "should return true if the keyword include '*' character" do
+          @germany.invert_order_of_object_and_verbs?('wahr*').should be_true
+        end
+        
+        it "should return true if the keyword include '*' char" do
+          @portuguese.invert_order_of_object_and_verbs?('verdadeiro*').should be_true
+        end
+        
+        it "should return true if one keyword include '*' char" do
+          @germany.invert_order_of_object_and_verbs?('wahr*|verdadeiro').should be_true
+        end
+        
+        it "should return true if the two keywords include '*' char" do
+          @portuguese.invert_order_of_object_and_verbs?('wahr*|verdadeiro*').should be_true
+        end
+        
+        it "should return false if the keyword not include '*' character" do
+          @portuguese.invert_order_of_object_and_verbs?('verdadeiro').should be_false
+        end
+        
+        it "should return false if the keyword not include '*' char" do
+          @spanish.invert_order_of_object_and_verbs?('falso').should be_false
+        end
+        
+        it "should return false if the keyword is nil" do
+          @germany.invert_order_of_object_and_verbs?(nil).should be_false
+        end
+        
+      end
+      
+      context 'when values from keywords' do
+        
+        it "should return the empty Hash for non values of keyword" do
+          stub_keywords!(@portuguese, {})
+          @portuguese.values_from_keywords('hooks').should eql({})
+        end
+        
+        it "should return the values for values fo keyword" do
+          stub_keywords!(@portuguese, { 'hooks' => { 'each' => 'cada|de_cada'}})
+          @portuguese.values_from_keywords('hooks').should eql({'each' => 'cada|de_cada'})
+        end
+        
+        it "should return the empty values for non values of middle keyword" do
+          stub_keywords!(@germany, { 'hooks' => {}})
+          @germany.values_from_keywords('hooks').should eql({})
+        end
+        
+      end
+    
+      context '#basic_keywords' do
+        
+        it "should ignore hooks from keywords" do
+          stub_keywords!(@portuguese, { 'subject' => 'assunto', 'hooks' => {'all' => 'todos'}})
+          @portuguese.basic_keywords.should eql({'subject' => 'assunto'})
+        end
+        
+        it "should ignore matchers from keywords" do
+          stub_keywords!(@portuguese, { 'subject' => 'assunto', 'matchers' => {'be' => 'ser'}})
+          @portuguese.basic_keywords.should eql({'subject' => 'assunto'})
+        end
+        
+        it "should ignore matchers and hooks" do
+          stub_keywords!(@portuguese, {'describe' => 'descreva', 'should' => 'deve', 'should_not' => 'nao_deve', 'matchers' => {'eql' => 'igl'}, 'hooks' => {'all' => 'todos'}})
+          @portuguese.basic_keywords.should eql({'describe' => 'descreva', 'should' => 'deve', 'should_not' => 'nao_deve'})
+        end
+        
+        it "should include all the basic keywords" do
+          stub_keywords!(@portuguese, {'describe' => 'descreva', 'matchers' => { 'eql' => 'igual_a'}})
+          @portuguese.basic_keywords.should eql({'describe' => 'descreva'})
+        end
+        
+      end
+    
+      context '#advanced_keywords' do
+        
+        it "should ignore all the basic keywords" do
+          stub_keywords!(@portuguese, {'describe' => 'descreva', 'matchers' => { 'equal' => 'igual' }})
+          @portuguese.advanced_keywords.should eql({'matchers' => {'equal' => 'igual'}})
+        end
+        
+        it "should accept hooks keywords" do
+          stub_keywords!(@portuguese, {'subject' => 'assunto', 'it' => 'isto', 'hooks' => {'all' => 'todos'}})
+          @portuguese.advanced_keywords.should eql({'hooks' => {'all' => 'todos'}})
+        end
+        
+        it "should accept hooks and matchers" do
+          stub_keywords!(@portuguese, {'subject' => 'assunto', 'hooks' => {'all' => 'todos'}, 'matchers' => { 'include' => 'inclua' }})
+          @portuguese.advanced_keywords.should eql({'hooks' => {'all' => 'todos'}, 'matchers' => {'include' => 'inclua'}})
         end
         
       end