rspec-i18n 1.1.0 → 1.2.0

data/spec/spec-i18n/example/pending_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+include Spec::Example
+
+describe Pending do
+  
+  describe 'in portuguese for example' do
+    
+    before(:each) do
+      @keywords = { "pending" => 'pendente|pendencia'}
+      stub_language!('pt', @keywords)
+    end
+
+    it "should have the translate pending method" do
+      Pending.translate_pending_keywords
+      name_methods = methods.to_symbols
+      [:pendente, :pendencia].each do |translated_pending_method|
+        name_methods.should include(translated_pending_method)
+      end
+    end
+    
+  end
+  
+  describe 'in spanish for example' do
+    
+    before(:each) do
+      @keywords = { "pending" => 'spec_pendente|pendenciaa'}
+      stub_language!('es', @keywords)
+    end
+
+    it "should have the translate pending method" do
+      Pending.translate_pending_keywords
+      name_methods = methods.to_symbols
+      [:spec_pendente, :pendenciaa].each do |translated_pending_method|
+        name_methods.should include(translated_pending_method)
+      end
+    end
+    
+  end
+  
+end

data/spec/spec-i18n/example/subject_spec.rb

@@ -5,29 +5,30 @@ module Spec
     describe "implicit subject" do
       
       before(:each) do
-        @pt = portuguese_language({'subject' => 'assunto', 'should' => 'deve',
-                                    'should_not' => 'nao_deve','matchers' => {}})
-        Subject::ExampleMethods.register_subjects
-        @es = spanish_language({'subject' => 'asunto', 'should' => 'deve',
-                                'should_not' => 'nao_deve', 'matchers' => {}})
+        @keywords = {'subject' => 'assunto|asunto', 
+          'should' => 'deve|deveria',
+          'should_not' => 'nao_deve|nao_deveria','matchers' => {}}
+        stub_language!("pt", @keywords)
         Subject::ExampleMethods.register_subjects
+        @name_methods = Subject::ExampleMethods.instance_methods.to_symbols
       end
 
       it 'should have the subject translated' do
-        values = @pt['subject'].split('|')
-        values << @es['subject'].split('|')
-        values.flatten.each do |value_method|
-          Subject::ExampleMethods.instance_methods.should be_include(value_method)
+        [:assunto, :asunto].each do |translated_subject|
+          @name_methods.should include(translated_subject)
+        end
+      end
+      
+      it "should have the 'should' method translated in subject" do
+        [:deve, :deveria].each do |should_method|
+          @name_methods.should include(should_method)
         end
       end
 
       it "should have the should and should_not method trasnlated" do
-        values = @pt['should'].split('|')
-        other_values = @pt['should_not'].split('|')
-        values << other_values
-        values.flatten.each do |value_method|
-          Subject::ExampleMethods.instance_methods.should be_include(value_method)
-        end        
+        [:nao_deve, :nao_deveria].each do |should_not_method|
+          @name_methods.should include(should_not_method)
+        end
       end
       
       describe "with a class" do
@@ -64,15 +65,7 @@ module Spec
           @group = Class.new do
             extend  Spec::Example::Subject::ExampleGroupMethods
             include Spec::Example::Subject::ExampleMethods
-            class << self
-              def described_class
-                Array
-              end
-            end
-            def described_class
-              self.class.described_class
-            end
-            
+                        
             subject {
               [1,2,3]
             }
@@ -91,7 +84,7 @@ module Spec
         doubly_nested_group = Class.new(nested_group)
 
         example = doubly_nested_group.new
-        example.subject.should == [1,2,3]
+        example.asunto.should == [1,2,3]
       end
 
     end
@@ -99,26 +92,19 @@ module Spec
     describe ".its (to access subject's attributes)" do
       
       before(:each) do
-        @its_examples = {'subject' => 'assunto', 'its' => 'exemplos', 'matchers' => {}}
-        @pt = portuguese_language(@its_examples)
-        Subject::ExampleGroupMethods.register_subjects
-        @es = spanish_language({'subject' => 'assunto', 'its' => 'ejemplos', 'matchers' => {}})
+        @keywords = {'subject' => 'assunto', 'its' => 'exemplos', 'matchers' => {}}
+        stub_language!("pt", @keywords)
         Subject::ExampleGroupMethods.register_subjects
       end
    
-     with_sandboxed_options do
-        it "passes when expectation should pass" do
-          group = Class.new(ExampleGroupDouble).describe(Array)
-          child = group.exemplos(:length) { should == 0 }
-          child.run(options).should == true
-        end
-        
-        it "fails when expectation should fail" do
-          group = Class.new(ExampleGroupDouble).describe(Array)
-          child = group.ejemplos(:length) { should == 1 }
-          child.run(options).should == false
-        end
+      with_sandboxed_options do
+         it "passes when expectation should pass" do
+           group = Class.new(ExampleGroupDouble).describe(Array)
+           child = group.exemplos(:length) { should == 0 }
+           child.run(options).should == true
+         end
       end
+    
     end
 
   end

data/spec/spec-i18n/expectations/kernel_spec.rb

@@ -1,25 +1,39 @@
 require 'spec_helper'
 
 describe Object, "#should and #should_not" do
-    
+  
   before(:each) do
-    @pt = SpecI18n::Parser::NaturalLanguage.get("pt")
-    @es = SpecI18n::Parser::NaturalLanguage.get("es")
-    @languages = {"pt" => @pt,"es" => @es}
-    @pt_keywords = {"should" => "deve", "should_not" => "nao_deve"}
-    @es_keywords = {"should" => "debe", "should_not" => "no_debe"}
-    @pt.stub!(:keywords).and_return(@pt_keywords)
-    @es.stub!(:keywords).and_return(@es_keywords)
+    @keywords = { 'should' => 'deve|deveria', 'should_not' => 'nao_deve|nao_deveria'}
+    stub_language!('pt', @keywords)
+    Kernel.register_expectations_keywords
   end
-
-  it "should have the 'should' and 'should_not' methods translated" do
-    @languages.each do |lang, language|
-      SpecI18n.stub!(:natural_language).and_return(language)
-      Kernel.register_expectations_keywords
-      language.expectation_keywords.values.to_a.flatten.each do |keyword|
-        Kernel.methods.should include(keyword)
+  
+  context 'when #should' do
+    
+    it "should translate the #should method" do
+      [:deve, :deveria].each do |expetation_method|
+        Kernel.methods.to_sym.should include(expetation_method)
+      end
+    end
+    
+    it "should use the #should method" do
+      1.deve == 1
+    end
+    
+  end
+  
+  context 'when #should_not' do
+    
+    it "should translate the #should_not method" do
+      [:nao_deve, :nao_deveria].each do |expectation_method|
+        Kernel.methods.to_sym.should include(expectation_method)
       end
     end
+    
+    it "should use the #should_not method" do
+      2.should_not == 1
+    end
+    
   end
   
 end

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

@@ -5,20 +5,20 @@ module Spec
     describe "[actual.should] be_close(expected, delta)" do
       
       before(:each) do
-        @expected_matcher = {'matchers' => { 'be_close' => 'estar_perto'} }
-        portuguese_language(@expected_matcher)
+        @keywords = {'matchers' => { 'be_close' => 'estar_perto|estar_proximo'} }
+        stub_language!("pt", @keywords)
         Spec::Matchers.register_all_matchers
       end
       
       it "should register the be_close matcher" do
-        values = @expected_matcher['matchers']['be_close'].split('|')
-        values.each do |value_method|
-          Object.instance_methods.should be_include(value_method)
+        [:estar_perto, :estar_proximo].each do |translate_matcher|
+          methods.to_symbols.should include translate_matcher          
         end
       end
       
       it "matches when actual == expected" do
         estar_perto(5.0, 0.5).matches?(5.0).should be_true
+        estar_proximo(5.0, 0.5).matches?(5.0).should be_true
       end
       
       it "matches when actual < (expected + delta)" do
@@ -28,9 +28,11 @@ module Spec
       it "does not match when actual == (expected - delta)" do
         estar_perto(5.0, 0.5).matches?(4.5).should be_false
       end
+      
       it "does not match when actual < (expected - delta)" do
         estar_perto(5.0, 0.5).matches?(4.49).should be_false
       end
+      
       it "does not match when actual == (expected + delta)" do
         estar_perto(5.0, 0.5).matches?(5.5).should be_false
       end

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

@@ -5,15 +5,14 @@ module Spec
     describe 'the be_instance_of method' do
       
       before(:each) do
-        @expected_matcher = { 'matchers' => { 'be_an_instance_of' => 'ser_instancia_de'} }
-        portuguese_language(@expected_matcher)
+        @keywords = { 'matchers' => { 'be_an_instance_of' => 'ser_instancia_de|ser_instancia'} }
+        stub_language!("pt", @keywords)
         Spec::Matchers.register_all_matchers
       end
       
       it "register the be_an_instance_of method" do
-        values = @expected_matcher['matchers']['be_an_instance_of'].split('|')
-        values.each do |value_method|
-          Object.instance_methods.should be_include(value_method)
+        [:ser_instancia_de, :ser_instancia].each do |translated_matcher|
+          methods.to_symbols.should include(translated_matcher)
         end
       end
       

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

@@ -5,16 +5,13 @@ module Spec
     describe 'the be_kind_of method' do
       
       before(:each) do
-        @expected_matcher = { 'matchers' => { 'be_a_kind_of' => 'ser_do_tipo'} }
-        portuguese_language(@expected_matcher)
+        @keywords = { 'matchers' => { 'be_a_kind_of' => 'ser_do_tipo'} }
+        stub_language!("pt", @keywords)
         Spec::Matchers.register_all_matchers
       end
       
       it "register the be_an_instance_of method" do
-        values = @expected_matcher['matchers']['be_a_kind_of'].split('|')
-        values.each do |value_method|
-          Object.instance_methods.should be_include(value_method)
-        end
+        methods.to_symbols.should include(:ser_do_tipo)
       end
       
       it "passes if actual is instance of expected class" do

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

@@ -1,13 +1,132 @@
+# coding: UTF-8
 require 'spec_helper'
 
 describe "should be_predicate" do
   
-  before(:each) do
-    portuguese_language({"matchers" => {"be" => "ser"}, "true" => "verdadeiro"})
-    Spec::Matchers.register_all_matchers
+  context 'when translate the be matcher' do
+    
+    it "should have the translate method" do
+      stub_language!('pt', {'matchers' => {'be' => 'ser'}})
+      Spec::Matchers.translate_be_matcher
+      methods.to_sym.should include(:ser)          
+    end
+    
+    it "should have the be translate matchers" do
+      stub_language!('de', { 'matchers' => { 'be' => 'sein' }})
+      Spec::Matchers.translate_be_matcher
+      methods.to_sym.should include(:sein)
+    end
+    
+    it "should not raise exception for the be empty keyword" do
+      stub_language!('pt', { 'name' => 'Portuguese', 'native' => 'Português'})
+      lambda { Spec::Matchers.translate_be_matcher }.should_not raise_exception
+    end
+    
+  end
+  
+  context 'when method missing' do
+    
+    before(:each) do
+      include Spec::Matchers
+      @keywords = { 'matchers' => { 'be' => 'ser' } }
+      stub_language!('pt', @keywords)
+    end
+    
+    it "should return a Be Predicate" do
+      Spec::Matchers::BePredicate.should_receive(:new).with(:be_something)
+      method_missing(:be_something)
+    end
+    
+    it "should not return a Be Predicate" do
+      Spec::Matchers::BePredicate.should_not_receive(:new)
+      method_missing(:have_something)
+    end
+    
+    it "should return a Has Predicate" do
+      Spec::Matchers::Has.should_receive(:new).with(:have_something)
+      method_missing(:have_something)
+    end
+    
+    it "should not return a Has Predicate" do
+      Spec::Matchers::Has.should_not_receive(:new)
+      method_missing(:be_something)
+    end
+    
+    it "when don't have the be word in the language should return a Be Predicate" do
+      stub_language!('es', {'name' => 'Spanish', 'native' => 'Español'})
+      Spec::Matchers::BePredicate.should_receive(:new).with(:be_something)
+      method_missing(:be_something)
+    end
+    
+  end
+  
+  context 'when have? in method missing' do
+    
+    before(:each) do
+      include Spec::Matchers
+    end
+        
+    it "should return true(0 or anything) for string match" do
+      have_predicate?(:have_exactly).should be_true
+    end
+    
+    it "should return true for have at least method" do
+      have_predicate?(:have_at_least).should be_true
+    end
+    
+    it "should return true for have at most method" do
+      have_predicate?(:have_at_most).should be_true
+    end
+    
+    it "should return false(false or nil) for not string match" do
+      have_predicate?(:be_true).should be_false
+    end
+    
+    it "should return nil for not string match" do
+      have_predicate?(:be_false).should be_false
+    end
+    
   end
   
-  context "be predicate" do
+  context 'when be_predicate? in method missing' do
+    
+    before(:each) do
+      include Spec::Matchers
+    end
+    
+    it "should return true for be true string match" do
+      be_predicate?(:be_true).should be_true
+    end
+    
+    it "should return true for the be false string match" do
+      be_predicate?(:be_false).should be_true
+    end
+    
+    it "should return true for the be_something string match" do
+      be_predicate?(:be_something).should be_true
+    end
+    
+    it "should return false for the have string match" do
+      be_predicate?(:have).should be_false
+    end
+    
+    it "should return true for the have something string match" do
+      be_predicate?(:have_something).should be_false
+    end
+    
+    it "should return true for the have exactly string match" do
+      be_predicate?(:have_exactly).should be_false
+    end
+    
+  end
+  
+  context 'when be predicate' do
+    
+    before(:each) do
+      @keywords = {"matchers" => {"be" => "ser",  "true_word" => "verdadeiro"}}
+      stub_language!("pt", @keywords)
+      Spec::Matchers.translate_be_matcher
+    end
 
     it "should pass with be language translated" do
       atual = stub("atual", :feliz? => true)
@@ -15,136 +134,182 @@ describe "should be_predicate" do
     end
   
     it "should fail when actual returns false for :predicate?" do
-        
-      pending('verify rspec 1.3')
-    
       atual = stub("atual", :feliz? => false)
       lambda {
-        atual.should be_feliz
+        atual.should ser_feliz
       }.should fail_with("expected feliz? to return true, got false")
     end
   
     it "should fail when actual returns false for :predicate?" do
-    
-      pending('verify rspec 1.3')
-    
       atual = stub("atual", :feliz? => nil)
       lambda {
-        atual.should be_feliz
+        atual.should ser_feliz
       }.should fail_with("expected feliz? to return true, got nil")
     end
   end
   
-  context "be words" do
+  context 'when be words' do
+    
     before(:each) do
       @pt = Parser::NaturalLanguage.get("pt")
       @es = Parser::NaturalLanguage.get("es")
-      include Spec::Matchers
-      @pt_keywords = { "matchers" => {'be' => 'ser',
-        "true_word" => "verdadeiro", "empty_word" => "vazio",
-        "false_word" => "falso", 'nil_word' => 'nulo'}}
-      @pt.stub!(:keywords).and_return(@pt_keywords)
-      @es_keywords = { "matchers" => {'be' => 'ser',
-        "true_word" => "verdadero", "false_word" => "falso", 
-        'nil_word' => 'nulo', 'empty_word' => "vazio"}}
-      @es.stub!(:keywords).and_return(@es_keywords)
-    end
-    
-    ['true', 'false', 'nil', 'empty'].each do |ruby_type|
-      context "be #{ruby_type}" do
-          
-        it "should translate #{ruby_type} keyword for pt" do
-          SpecI18n.stub!(:natural_language).and_return(@pt)
-          matcher_be = "#{@pt_keywords['matchers']['be']}"
-          matcher = @pt_keywords['matchers']["#{ruby_type}_word"]
-          expected = "#{matcher_be}_#{matcher}"
-          eval <<-MATCHER
-            Be.matcher_be_some(:#{ruby_type} => true).should == [expected.to_sym ]
-          MATCHER
+    end
+    
+    describe "when matcher be some word(true, false,nil or empty)" do
+      
+      context 'when write specifications exactly as it is in languages.yml' do
+        
+        before(:each) do
+          @pt_keywords = { "matchers" => {'be' => 'ser|estar', 
+            "true_word" => "verdadeiro|verdade",  "false_word" => "falso|muito_falso",
+            "empty_word" => "vazio|sem_elemento", "nil_word" => "nulo|null" }}
+          stub_language!('pt', @pt_keywords)
+        end
+        
+        it "should translate true word for languages" do
+          expected = [:ser_verdadeiro, :ser_verdade, :estar_verdadeiro, :estar_verdade]
+          Spec::Matchers.matcher_be_some(:true).should == expected
+        end
+        
+        it "should translate false word for languages" do
+          expected = [:ser_falso, :ser_muito_falso, :estar_falso, :estar_muito_falso]
+          Spec::Matchers.matcher_be_some(:false).should == expected
+        end
+        
+        it "should translate false word for languages" do
+          expected = [:ser_vazio, :ser_sem_elemento, :estar_vazio, :estar_sem_elemento]
+          Spec::Matchers.matcher_be_some(:empty).should == expected
+        end
+        
+        it "should translate nil word for languages" do
+          expected = [:ser_nulo, :ser_null, :estar_nulo, :estar_null]
+          Spec::Matchers.matcher_be_some(:nil).should == expected
+        end
+      end
+      
+      context 'when write specifications of objects, verbs and predicates in different orders' do
+        
+        before(:each) do
+          @keywords = { 'matchers' => { 'be' => 'sein', 'true_word' => 'wahr*',
+            'false_word' => 'falsch*', 'nil_word' => 'null*', 'empty_word' => 'leer*' } }
+          stub_language!('de', @keywords)
+        end
+        
+        it "should return be true in different order" do
+          Spec::Matchers.matcher_be_some(:true).should eql([:wahr_sein])
+        end
+        
+        it "should return be_false in different order" do
+          Spec::Matchers.matcher_be_some(:false).should eql([:falsch_sein])
+        end
+        
+        it "should return be_nil in different order" do
+          Spec::Matchers.matcher_be_some(:nil).should eql([:null_sein])
+        end
+        
+        it "should return be_empty in different order" do
+          Spec::Matchers.matcher_be_some(:empty).should eql([:leer_sein])
         end
         
-         it "should translate #{ruby_type} keyword for es" do
-           SpecI18n.stub!(:natural_language).and_return(@es) 
-           matcher_be = "#{@es_keywords['matchers']['be']}"
-           matcher = @es_keywords['matchers']["#{ruby_type}_word"]
-           expected = "#{matcher_be}_#{matcher}"
-           eval <<-MATCHER
-             Be.matcher_be_some(:#{ruby_type} => true).should == [expected.to_sym ]
-           MATCHER
-         end
       end
+      
     end
     
     context "be true predicate" do
-         
-      it "should pass when actual equal?(true)" do
-          [@pt, @es].each do |language|
-            SpecI18n.stub!(:natural_language).and_return(language)
-            Be.translate_be_true
-            matcher_be_some(:true => true).each do |word_be_true|
-                eval <<-BE_TRUE
-                  true.should #{word_be_true}
-                  1.should #{word_be_true}
-                BE_TRUE
-            end
-          end
-        end
+      
+      before(:each) do
+        @pt_keywords = { "matchers" => {'be' => 'ser', "true_word" => "verdadeiro|verdade" }}
+        stub_keywords!(@pt, @pt_keywords)
+        mock_natural_language(@pt)
+        Spec::Matchers.translate_be_true
+      end
+               
+      it "should pass when actual equal?(true) for language" do
+        true.should ser_verdadeiro
+        true.should ser_verdade
+      end
+      
+      it "should pass when actual is 1" do
+        1.should ser_verdadeiro
+        1.should ser_verdade
+      end
       
     end
 
     context "be false predicate" do
       
-      it "should pass when actual equal?(true)" do
-          [@pt, @es].each do |language|
-            SpecI18n.stub!(:natural_language).and_return(language)
-            Be.translate_be_false
-            matcher_be_some(:false => true).each do |word_be_false|
-                eval <<-BE_FALSE
-                  false.should #{word_be_false}
-                  nil.should #{word_be_false}
-                BE_FALSE
-            end
-          end
-        end
+      before(:each) do
+        @pt_keywords = { "matchers" => {'be' => 'ser', "false_word" => "falso|muito_falso" }}
+        stub_keywords!(@pt, @pt_keywords)
+        mock_natural_language(@pt)
+        Spec::Matchers.translate_be_false
+      end
+      
+      it "should pass when actual equal?(false) for language" do
+        false.should ser_falso
+        false.should ser_muito_falso 
+      end
       
+      it "should pass when actual equal?(nil) for language" do
+        nil.should ser_falso
+        nil.should ser_muito_falso
+      end
       
     end
     
     context "be nil predicate" do
+      
+      before(:each) do
+        @pt_keywords = { "matchers" => {'be' => 'ser', "nil_word" => "nulo|null" }}
+        stub_keywords!(@pt, @pt_keywords)
+        mock_natural_language(@pt)
+        Spec::Matchers.translate_be_nil
+      end
         
       it "should pass when actual is nil" do
-        [@pt, @es].each do |language|
-          SpecI18n.stub!(:natural_language).and_return(language)
-          Be.translate_be_nil
-          matcher_be_some(:nil => true).each do |word_be_nil|
-              eval <<-BE_NIL                
-                nil.should #{word_be_nil}
-              BE_NIL
-          end
-        end
+        nil.should ser_nulo
+        nil.should ser_null
       end
+      
+      it "should pass when not be nil and actual is not nil" do
+        :not_nil.should_not ser_nulo
+        :not_nil.should_not ser_null
+      end
+      
     end
     
     context "be empty predicate" do
-      it "should pass when actual is nil" do
-        [@pt, @es].each do |language|
-          SpecI18n.stub!(:natural_language).and_return(language)
-          Be.translate_be_empty
-          matcher_be_some(:empty => true).each do |word_be_nil|
-              eval <<-BE_EMPTY                
-                [].should #{word_be_nil}
-              BE_EMPTY
-          end
-        end
+      
+      before(:each) do
+        @pt_keywords = { "matchers" => {'be' => 'ser', "empty_word" => "vazio|sem_elemento" }}
+        stub_keywords!(@pt, @pt_keywords)
+        mock_natural_language(@pt)
+        Spec::Matchers.translate_be_empty
+      end
+      
+      it "should pass when actual is empty" do
+        [].should ser_vazio
+        [].should ser_sem_elemento
       end
+      
+      it "should pass when not is empty and actual is not empty" do
+        [:not_empty].should_not ser_vazio
+        [:not_empty].should_not ser_sem_elemento
+      end
+      
     end
     
   end
   
-  context "convert the be word" do
+  context 'when be to english' do
+    
     it 'should convert be word to english with two parameters' do
       be_to_english(:ser_feliz, 'ser|estar').should == :be_feliz
     end
+    
+    it "should convert be words to english" do
+      be_to_english(:estar_feliz, 'ser|estar').should == :be_feliz
+    end
   
     it "should convert be word to english" do
       be_to_english(:ser_feliz, :ser).should == :be_feliz
@@ -161,6 +326,7 @@ describe "should be_predicate" do
     it "should keep the same word for the nil be word" do
       be_to_english(:be_include, nil).should == :be_include
     end
+        
   end
   
 end