rspec-i18n 1.1.0 → 1.2.0

data/spec/spec-i18n/dsl/main_spec.rb

@@ -7,23 +7,65 @@ describe Main do
     @pt = SpecI18n::Parser::NaturalLanguage.get("pt")
     @es = SpecI18n::Parser::NaturalLanguage.get("es")
     @languages = {"pt" => @pt,"es" => @es}
-    @pt_keywords = {"describe" => "descreva"}
-    @es_keywords = {"describe" => "descreva"}
-    @pt.stub!(:keywords).and_return(@pt_keywords)
-    @es.stub!(:keywords).and_return(@es_keywords)
   end
 
   describe 'the manipulation of methods of the domain specific language' do
+    before(:each) do
+      @pt_keywords = {"describe" => "descreva|contexto"}
+      @es_keywords = {"describe" => "descreba|describir"}
+      @pt.stub!(:keywords).and_return(@pt_keywords)
+      @es.stub!(:keywords).and_return(@es_keywords)
+    end
     
-      it "should have the methods of the dsl keywords of the language specified" do
-        @languages.each do |lang, language|
-          SpecI18n.stub!(:natural_language).and_return(language)
-          Spec::DSL::Main.register_adverbs
-          language.dsl_keywords.values.flatten.each do |keyword|
-            Main.methods.should include(keyword)
-          end
-        end
+    it "should have the methods of the dsl keywords of the language specified" do
+      mock_natural_language(@pt)
+      Main.register_adverbs
+      [:descreva, :contexto].each do |keyword|
+        Main.methods.all_to_symbols.should include(keyword)
       end
+    end    
+    
+    it "should have the method for other language" do
+      mock_natural_language(@es)
+      Main.register_adverbs
+      [:descreba, :describir].each do |keyword|
+        Main.methods.all_to_symbols.should include(keyword)
+      end
+    end    
+    
+  end
+
+  describe "the manipulation of shared examples for"  do
+    
+    before(:each) do
+      @keywords = { "shared_examples_for" => "exemplos_distribuidos|exemplos_distribuidos_para" } 
+      stub_language!("pt", @keywords)
+      Main.translate_shared_examples_for
+    end
+    
+    it "should register all the keywords for the shared examples for" do
+      [:exemplos_distribuidos, :exemplos_distribuidos_para].each do |keyword|
+        Main.methods.to_symbols.should include(keyword)
+      end
+    end
+    
+  end
+
+  describe "when translate share_as" do
+    
+    before(:each) do
+      @keywords = { "share_as" => 'distribua|distribua_como' }
+      stub_language!('pt', @keywords)
+      Main.translate_share_as_keywords
+    end
+    
+    it "should include the translate methods" do
+      main_methods = Main.methods.to_symbols
+      [:distribua, :distribua_como].each do |method_name|
+        main_methods.should include(method_name)
+      end
+    end
+    
   end
 
 end

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

@@ -3,82 +3,205 @@ require 'spec_helper'
 module Spec
   module Example
     describe BeforeAndAfterHooks do
-      
-      before(:each) do
-        @pt = SpecI18n::Parser::NaturalLanguage.get("pt")
-        @es = SpecI18n::Parser::NaturalLanguage.get("es")
-        @pt_keywords = {"before" => "antes", "after" => "antes",
-          "hooks" => {"each" => "cada", "all" => "todos", 
-                      "suite" => "suite"}}
-        @es_keywords = { "before" => "antes", "after" => "antes",
-          "hooks" => {"each" => "cada", "all" => "tudo",
-                      "suite" => "suite"}}
-        @pt.stub!(:keywords).and_return(@pt_keywords)
-        @es.stub!(:keywords).and_return(@es_keywords)
-        @languages = {"pt" => @pt, "es" => @es}
-      end
-      
-      it "should include all i18n methods to Before and After Hooks" do
-        @languages.each do |lang, language|
-          SpecI18n.stub!(:natural_language).and_return(language)
-          Spec::Example::BeforeAndAfterHooks.register_hooks
-          language.before_and_after_keywords.keys.map do |keyword|
-            BeforeAndAfterHooks.methods.should include(keyword)
+            
+      describe 'when translate the hooks' do
+        
+        context 'when portuguese' do
+          
+          before(:each) do
+            @keywords = { 'before' => 'antes|anterior', 'after' => 'depois|posterior' }
+            stub_language!('pt', @keywords)
+            Spec::Example::BeforeAndAfterHooks.register_hooks
+          end
+
+          it "should include all i18n methods to Before Hooks" do
+            name_methods = BeforeAndAfterHooks.methods.to_symbols
+            [:antes, :anterior].each do |translated_method|
+              name_methods.should include(translated_method)
+            end
+          end
+          
+          it "should include all i18n methods to After Hooks" do
+            name_methods = BeforeAndAfterHooks.methods.to_symbols
+            [:depois, :posterior].each do |translated_method|
+              name_methods.should include(translated_method)
+            end
           end
+          
         end
+            
       end
       
-      context "the before hook" do
+      describe 'when hooks' do
         
-        it "should translate the :each parameters and parse options" do
-          @languages.each do |lang, language|
-            SpecI18n.stub!(:spec_language).and_return(lang)            
-            SpecI18n.stub!(:natural_language).and_return(language)
-            scope = language.hooks_params_keywords["each"].first
-            self.should_receive(:before_each_parts)
-            before_parts(scope)
-          end
+        before(:each) do
+           SpecI18n.stub!(:spec_language).and_return('pt')
+           @keywords = { 'hooks' => { 'each' => 'cada|de_cada', 'all' => 'todos|de_todos', 'suite' => 'suite|da_suite'}}
+           stub_language!('pt', @keywords)
         end
-    
-        it "should translate the :all scope and call the right method" do
-          @languages.each do |lang, language|
-            SpecI18n.stub!(:spec_language).and_return(lang)            
-            SpecI18n.stub!(:natural_language).and_return(language)
-            scope = language.hooks_params_keywords["all"].first
-            self.should_receive(:before_all_parts)
-            before_parts(scope)
+              
+        describe "the before hook" do
+          
+          context 'when :each' do
+                  
+            it "should translate the :each parameters and parse options" do
+              [:cada, :de_cada].each do |scope|
+                BeforeAndAfterHooks.should_receive(:before_each_parts)
+                BeforeAndAfterHooks.before_parts(scope)
+              end
+            end
+            
+            it "should not call the :all parameters for :each hook" do
+              BeforeAndAfterHooks.should_not_receive(:before_all_parts)
+              [:cada, :de_cada].each do |scope|                 
+                BeforeAndAfterHooks.before_parts(scope)              
+              end
+            end
+            
+            it "should not call the :suite parameters for :suite hook" do
+              BeforeAndAfterHooks.should_not_receive(:before_suite_parts)
+              [:cada, :de_cada].each do |scope|                 
+                BeforeAndAfterHooks.before_parts(scope)
+              end
+            end
           end
-        end
-    
-        it "should translate the :suite scope and call the right method" do
-          @languages.each do |lang, language|
-            SpecI18n.stub!(:spec_language).and_return(lang)            
-            SpecI18n.stub!(:natural_language).and_return(language)
-            scope = language.hooks_params_keywords["suite"].first
-            self.should_receive(:before_suite_parts)
-            before_parts(scope)
+          
+          context 'when :all' do
+             
+             it "should translate the :all parameter" do
+               [:todos, :de_todos].each do |scope|
+                 BeforeAndAfterHooks.should_receive(:before_all_parts)
+                 BeforeAndAfterHooks.before_parts(scope)
+               end
+             end
+             
+             it "should not call the :each parameter" do
+               BeforeAndAfterHooks.should_not_receive(:before_each_parts)
+               [:todos, :de_todos].each do |scope|
+                 BeforeAndAfterHooks.before_parts(scope)
+               end
+             end
+             
+             it "should not call the :suite parameter" do
+               BeforeAndAfterHooks.should_not_receive(:before_suite_parts)
+               [:todos, :de_todos].each do |scope|
+                 BeforeAndAfterHooks.before_parts(scope)
+               end
+             end
+             
+           end
+          
+          context 'when :suite' do
+            
+            it "should translate the :suite parameter" do
+              [:suite, :da_suite].each do |scope|
+                BeforeAndAfterHooks.should_receive(:before_suite_parts)
+                BeforeAndAfterHooks.before_parts(scope)
+              end
+            end
+            
+            it "should not call the :each parameter" do
+                BeforeAndAfterHooks.should_not_receive(:before_each_parts)
+              [:suite, :da_suite].each do |scope|
+                BeforeAndAfterHooks.before_parts(scope)
+              end
+            end
+            
+            it "should not call the :all parameter" do
+              BeforeAndAfterHooks.should_not_receive(:before_all_parts)
+              [:suite, :da_suite].each do |scope|
+                BeforeAndAfterHooks.before_parts(scope)
+              end
+            end
+            
           end
+            
         end
-      end
       
-      context "the after hook" do
-        it "should translate the :all scope and call the right method" do
-          @languages.each do |lang, language|
-            SpecI18n.stub!(:spec_language).and_return(lang)            
-            SpecI18n.stub!(:natural_language).and_return(language)
-            scope = language.hooks_params_keywords["all"].first
-            self.should_receive(:after_all_parts)
-            after_parts(scope)
+        context "the after hook" do
+          
+          context 'when :each' do
+                  
+            it "should translate the :each parameters and parse options" do
+              [:cada, :de_cada].each do |scope|
+                BeforeAndAfterHooks.should_receive(:after_each_parts)
+                BeforeAndAfterHooks.after_parts(scope)
+              end
+            end
+            
+            it "should not call the :all parameters for :each hook" do
+              BeforeAndAfterHooks.should_not_receive(:after_all_parts)
+              [:cada, :de_cada].each do |scope|                 
+                BeforeAndAfterHooks.after_parts(scope)              
+              end
+            end
+            
+            it "should not call the :suite parameters for :suite hook" do
+              BeforeAndAfterHooks.should_not_receive(:after_suite_parts)
+              [:cada, :de_cada].each do |scope|                 
+                BeforeAndAfterHooks.after_parts(scope)
+              end
+            end
+          end
+          
+          context 'when :all' do
+             
+             it "should translate the :all parameter" do
+               [:todos, :de_todos].each do |scope|
+                 BeforeAndAfterHooks.should_receive(:after_all_parts)
+                 BeforeAndAfterHooks.after_parts(scope)
+               end
+             end
+             
+             it "should not call the :each parameter" do
+               BeforeAndAfterHooks.should_not_receive(:after_each_parts)
+               [:todos, :de_todos].each do |scope|
+                 BeforeAndAfterHooks.after_parts(scope)
+               end
+             end
+             
+             it "should not call the :suite parameter" do
+               BeforeAndAfterHooks.should_not_receive(:after_suite_parts)
+               [:todos, :de_todos].each do |scope|
+                 BeforeAndAfterHooks.after_parts(scope)
+               end
+             end
+             
           end
+        
+          context 'when :suite' do
+            
+            it "should translate the :suite parameter" do
+              [:suite, :da_suite].each do |scope|
+                BeforeAndAfterHooks.should_receive(:after_suite_parts)
+                BeforeAndAfterHooks.after_parts(scope)
+              end
+            end
+            
+            it "should not call the :each parameter" do
+                BeforeAndAfterHooks.should_not_receive(:after_each_parts)
+              [:suite, :da_suite].each do |scope|
+                BeforeAndAfterHooks.after_parts(scope)
+              end
+            end
+            
+            it "should not call the :all parameter" do
+              BeforeAndAfterHooks.should_not_receive(:after_all_parts)
+              [:suite, :da_suite].each do |scope|
+                BeforeAndAfterHooks.after_parts(scope)
+              end
+            end
+            
+          end
+        
         end
+        
       end
       
       context "grep the scope and call the hook" do
         
         before(:each) do
-          @pt = Spec::Runner.configuration.spec_language(:pt)
-          @language = SpecI18n::Parser::NaturalLanguage.get(@pt)
-          @hooks = @language.hooks_params_keywords 
+          @hooks = { 'each' => 'cada|de_cada', 'all' => 'todos|de_todos', 'suite' => 'suite|da_suite' }
         end
         
         it "should return the same scope if scope is in English" do
@@ -87,51 +210,50 @@ module Spec
           end
         end
         
-        it "should grep the scope each" do
-          scopes = @hooks["each"]
-          scopes.each do |scope|
-            grep_the_scope(scope, @hooks).should == :each            
+        context 'with String scope parameters' do
+          
+          it "should grep the scope each in translated values" do
+            ['cada', 'de_cada'].each do |scope|
+              grep_the_scope(scope, @hooks).should == :each            
+            end
           end
-        end
-        
-        it "should grep the scope all" do
-          scopes = @hooks["all"]
-          scopes.each do |scope|
-            grep_the_scope(scope, @hooks).should == :all
+
+          it "should grep the scope all in translated values" do
+            ['todos', 'de_todos'].each do |scope|
+              grep_the_scope(scope, @hooks).should == :all
+            end
           end
-        end
-        
-        it "should grep the scope suite" do
-          scopes = @hooks["suite"]
-          scopes.each do |scope|
-            grep_the_scope(scope, @hooks).should == :suite            
+
+          it "should grep the scope suite in translated values" do
+            ['suite', 'da_suite'].each do |scope|
+              grep_the_scope(scope, @hooks).should == :suite            
+            end
           end
+        
         end
         
-        context "with Symbol scopes" do
+        context "with Symbol scope parameters" do
           
-          it "should grep the scope :each" do
-            scopes = @hooks["each"].map { |hook| hook.to_sym }
-            scopes.each do |scope|
-              grep_the_scope(scope, @hooks).should == :each
+          it "should grep the scope each in translated values" do
+            [:cada, :de_cada].each do |scope|
+              grep_the_scope(scope, @hooks).should == :each            
             end
           end
 
-          it "should grep the scope :all" do
-            scopes = @hooks["all"].map { |hook| hook.to_sym }
-            scopes.each do |scope|
+          it "should grep the scope all in translated values" do
+            [:todos, :de_todos].each do |scope|
               grep_the_scope(scope, @hooks).should == :all
             end
           end
-          
-          it "should grep the scope :suite" do
-            scopes = @hooks["suite"].map { |hook| hook.to_sym }
-            scopes.each do |scope|
-              grep_the_scope(scope, @hooks).should == :suite
+
+          it "should grep the scope suite in translated values" do
+            [:suite, :da_suite].each do |scope|
+              grep_the_scope(scope, @hooks).should == :suite            
             end
           end
           
         end
+      
       end
           
     end

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

@@ -4,19 +4,37 @@ module Spec
   module Example
     describe ExampleGroupMethods do
       
-      before(:each) do
-        @languages = ["pt", "es", "en"]
+      context 'when it keywords' do
+        before(:each) do
+          @keywords = {"it" => "isto|especificar"}
+          stub_language!("pt", @keywords)
+          Spec::Example::ExampleGroupMethods.register_example_adverbs
+        end
+
+        it "should include the example translated methods" do
+          example_group_methods = Spec::Example::ExampleGroup.methods.to_symbols
+          [:isto, :especificar].each do |example_method|
+            example_group_methods.should include(example_method)
+          end
+        end
       end
       
-      it "should include #it example translated methods" do
-        @languages.each do |language|
-          Spec::Runner.configuration.spec_language(language)
-          language = SpecI18n::Parser::NaturalLanguage.get(language)
-          language.example_group_keywords.values.flatten.each do |keyword|
-            pending "I don't know wich module is included the keywords (Is 2:43 AM - I'll relaxing in my couch)"
+      context 'when it should behave like keywords' do
+        before(:each) do
+          @keywords = { 'it_should_behave_like' => 'deve_se_comportar_como|deve_se_comportar'}
+          stub_language!('pt', @keywords)
+          Spec::Example::ExampleGroupMethods.translate_it_should_behave_like
+        end
+        
+        it 'should include the it should behave like method translated' do
+          example_group_methods = Spec::ExampleGroup.methods.to_symbols
+          [:deve_se_comportar_como, :deve_se_comportar].each do |translated_method|
+            example_group_methods.should include(translated_method)
           end
         end
+        
       end
+      
     end
   end
 end