rspec-i18n 1.1.0 → 1.2.0

data/lib/spec-i18n/languages.yml

@@ -6,48 +6,118 @@
 
 # The English language => Just for example all the keywords
 "en":
-  name: 
-  native: 
-  describe: 
-  it: 
-  its: 
-  subject: 
-  should: 
+  name: English
+  native: English
+  describe:
+  it:
+  its:
+  pending:
+  subject:
+  shared_examples_for:
+  share_as:
+  it_should_behave_like:
+  should:
   should_not:
   before:
   after:
-  hooks:                                                    
+  hooks:
     each:
     all:
     suite:
-  matchers:                                                 
+  matchers:
     be:
-    true_word:
+    true_word: 
     false_word:
     nil_word:
     empty_word:
-    be_a_kind_of:
+    be_a_kind_of: 
     be_close:
     be_an_instance_of:
     eql:
     equal:
-    exist:
+    exist: 
     have:
-    have_exactly:
+    have_exactly: 
     have_at_least:
-    have_at_most:
+    have_at_most: 
     include:
     match:
-    raise_error:
+    raise_error: 
     satisfy:
 
+"ar":
+  name: Arabic
+  native: العربية
+
+"de":
+  name: German
+  native: Deutsch
+  describe: beschreibe|kontext
+  it: es
+  its:
+  pending:
+  subject: subjekt
+  share_as:
+  shared_examples_for: 
+  it_should_behave_like:
+  should: sollte
+  should_not: sollte_nicht
+  before: vorher
+  after: nachher
+  hooks:
+    each: von_jeder
+    all: von_alle
+    suite: suite
+  matchers:
+    be: sein
+    true_word: wahr*
+    false_word: falsch*
+    nil_word: null*
+    empty_word: leer*
+    be_a_kind_of: ein_typ*sein
+    be_close: nahe_liegen*
+    be_an_instance_of: 
+    eql: glc
+    equal: gleich
+    exist: wesen
+    have: haben
+    have_exactly: genau_haben*
+    have_at_least: mindestens_haben*
+    have_at_most: maximal_haben*
+    include: beinhalten*
+    match: passen*
+    raise_error: 
+    satisfy: erfüllen*
+
+# Please put the right words for this languages! =D
+
+"es":
+  name: Spanish
+  native: Español
+
+"en-au":
+    name: Australian
+    native: Australian
+
+"fr":
+  name: French
+  native: Français
+
+"ko":
+  name: Korean
+  native: 한국어
+
 "pt":
   name: Portuguese
-  native: português
+  native: Português
   describe: descreva|contexto
   it: isso|isto|especificar|exemplo
   its: exemplo_do_assunto # I don't know about this word
+  pending: pendente
   subject: assunto
+  shared_examples_for: exemplos_distribuidos|exemplo_distribuido
+  share_as: distribua_como
+  it_should_behave_like: deve_se_comportar_como
   should: deve
   should_not: nao_deve
   before: antes
@@ -76,37 +146,5 @@
     match: corresponder
     raise_error: mostrar_erro|mostrar_excessao
     satisfy: satisfazer
-
-# Please put the right words for this language! =D
-"es":
-  name: Spanish
-  native: español
-  describe: describir 
-  it: ejemplo
-  its: ejemplo_asunto # I don't know about this word
-  subject: asunto|tema
-  should: deberia
-  should_not: no_debe
-  before: antes
-  after: despues
-  hooks:
-    each: de_cada_ejemplo
-    all: de_todos_ejemplo
-    suite: suite
-  matchers:
-    be: 
-    true: 
-    be_a_kind_of: 
-    be_close: 
-    be_an_instance_of: 
-    eql: 
-    equal: 
-    exist: 
-    have: 
-    have_exactly: 
-    have_at_least: 
-    have_at_most: 
-    include: 
-    match: 
-    raise_error: 
-    satisfy: 
+    
+    

data/lib/spec-i18n/matchers.rb

@@ -2,5 +2,3 @@ require 'spec-i18n/matchers/be'
 require 'spec-i18n/matchers/method_missing'
 require 'spec-i18n/matchers/translate_basic_matchers'
 require 'spec-i18n/matchers/register_all_matchers'
-
-include Spec::Matchers

data/lib/spec-i18n/matchers/be.rb

@@ -2,70 +2,57 @@ require 'spec/matchers/dsl'
 
 module Spec
   module Matchers
-    class Be #:nodoc:
-      class << self
-        def register_be_matcher
-          language = SpecI18n.natural_language
-          be_matcher = language.keywords['matchers']['be']
-          
-          # TODO: working with warnings
-          return unless be_matcher
+    
+    class << self
       
-          be_matcher.split('|').map do |be_value|
-            alias_method be_value, :be
-          end
-        end
+      def translate_be_matcher
+        natural_language.keywords_of_be_word.collect { |be_value| alias_method be_value, :be }
       end
       
-    end      
-  
-    def translate_be_true
-      matcher_be_some(:true => true).each do |matcher|
-        Spec::Matchers.define matcher do
-          match do |actual|
-            !!actual
+      def translate_be_true
+        matcher_be_some(:true).each do |matcher|
+          Spec::Matchers.define(matcher) do
+            match do |actual|
+              !!actual
+            end
           end
         end
       end
-    end
-    
-    def translate_be_false
-      matcher_be_some(:false => true).each do |matcher|
-        Spec::Matchers.define matcher do
-          match do |actual|
-            !actual
+        
+      def translate_be_false
+        matcher_be_some(:false).each do |matcher|
+          Spec::Matchers.define(matcher) do
+            match do |actual|
+              !actual
+            end
           end
         end
       end
-    end
-    
-    def translate_be_nil
-      matcher_be_some(:nil => true).each do |matcher|
-        Spec::Matchers.define matcher do
-          match do |actual|
-            actual.nil?
+        
+      def translate_be_nil
+        matcher_be_some(:nil).each do |matcher|
+          Spec::Matchers.define(matcher) do
+            match do |actual|
+              actual.nil?
+            end
           end
         end
       end
-    end
-    
-    def translate_be_empty
-      matcher_be_some(:empty => true).each do |matcher|
-        Spec::Matchers.define matcher do
-          match do |actual|
-            actual.empty?
+        
+      def translate_be_empty
+        matcher_be_some(:empty).each do |matcher|
+          Spec::Matchers.define(matcher) do
+            match do |actual|
+              actual.empty?
+            end
           end
         end
       end
-    end
-    
-    def matcher_be_some(options={})
-      option = options.keys.select { |key| options[key] != nil }
-      language.word_be(option.to_s).map { |word| word.to_sym}
-    end
-    
-    def language
-      SpecI18n.natural_language
+        
+      def matcher_be_some(option)
+        natural_language.word_be(option.to_s).collect { |word| word.to_sym}
+      end
+      
     end
   
   end

data/lib/spec-i18n/matchers/method_missing.rb

@@ -1,25 +1,41 @@
 module Spec
   module Matchers
-    def method_missing(sym, *args, &block) # :nodoc:
-
-      begin
-        language = SpecI18n.natural_language
-        be_word = language.keywords['matchers']['be']      
-        sym = be_to_english(sym, be_word)
-      end
-      
-      return Matchers::BePredicate.new(sym, *args, &block) if sym.to_s =~ /^be_/
-      return Matchers::Has.new(sym, *args, &block) if sym.to_s =~ /^have_/
-      
-      super
+    
+    # Method Missing that returns Predicate for the respective sym word
+    # Search the translate be word in the languages.yml for the rspec-i18n try 
+    # to comunicate with the Rspec
+    #
+    def method_missing(sym, *args, &block) # :nodoc:\
+      matchers = natural_language.keywords['matchers']
+      be_word = matchers['be'] if matchers
+      sym = be_to_english(sym, be_word)
+      return Matchers::BePredicate.new(sym, *args, &block) if be_predicate?(sym)
+      return Matchers::Has.new(sym, *args, &block) if have_predicate?(sym)
+    end
+    
+    # Return something true(equivalent) for Be Predicate
+    #
+    def be_predicate?(sym)
+      sym.to_s =~ /^be_/
+    end
+    
+    # Return something true(equivalent) for Have predicate
+    #
+    def have_predicate?(sym)
+      sym.to_s =~ /^have_/
     end
     
-    # :ser_matcher == :be_matcher
-    # :be_true == :be_true
+    # Transform the word in be for rspec work properly
+    #
+    # be_to_english(:ser_feliz, :ser)        # => :be_feliz
+    # be_to_english(:estar_incluso, :estar)  # => :be_incluso
+    # be_to_english(:ser_feliz, 'ser|estar') # => :be_feliz
+    #
     def be_to_english(sym, be_word)
-      be_word = be_word || 'be'
-      
+      be_word = be_word || 'be' 
       sym.to_s.gsub(/#{be_word}/, 'be').to_sym
     end
-  end
+    alias :to_english :be_to_english
+  
+  end  
 end

data/lib/spec-i18n/matchers/register_all_matchers.rb

@@ -2,8 +2,7 @@ module Spec
   module Matchers
 
     def self.register_all_matchers
-      Spec::Matchers::Be.register_be_matcher
-      ["true", "false", "nil", "empty"].each do |matcher|
+      ["true", "false", "nil", "empty", "matcher"].each do |matcher|
         class_eval <<-BE_WORD
           translate_be_#{matcher}
         BE_WORD

data/lib/spec-i18n/matchers/translate_basic_matchers.rb

@@ -2,27 +2,53 @@ module Spec
   module Matchers
     class << self
       
-      RSPEC_MATCHERS = [ :be_close, :be_an_instance_of, :be_a_kind_of,
-                         :eql, :equal, :exist, :have, :have_at_least, 
-                         :have_at_most, :have_exactly, :include, :match, 
-                         :raise_error, :satisfy ]
+      RSPEC_MATCHERS = [:be_close, :be_an_instance_of, :be_a_kind_of,
+                        :eql, :equal, :exist, :have, :have_at_least, 
+                        :have_at_most, :have_exactly, :include, :match, 
+                        :raise_error, :satisfy ]
       
       MATCHERS_WITH_QUESTIONS = [ :eql, :equal ]
       
+      # Translate all the basic matcher for the Natural Language
+      #
       def translate_basic_matchers
-        language = SpecI18n.natural_language        
         RSPEC_MATCHERS.each do |rspec_matcher|
-          matcher = language.keywords['matchers'][rspec_matcher.to_s]
-
-          # TODO: Generating warnings for the incomplete languages
-          next unless matcher
-
-          matcher.split('|').map do |matcher_value|
-            alias_method "#{matcher_value}?", "#{rspec_matcher}?" if MATCHERS_WITH_QUESTIONS.include?(rspec_matcher)
-            alias_method matcher_value, rspec_matcher
-          end
+          matcher = natural_language.find_matcher(rspec_matcher)
+          translate_matcher(matcher, rspec_matcher)
         end
       end
+      
+      # Translate a matcher from a rspec_matcher
+      #
+      # Example: 
+      #   pt:
+      #     matchers:
+      #       be_close: estar_proximo
+      #       equal: igual
+      #
+      #  rspec_matcher = :be_close  ->  matcher = { "be_close" => ['estar_proximo']}
+      #
+      #  rspec_matcher = :equal     ->  matcher = { "equal"    => ['igual']}
+      #
+      #  and so on ...
+      #
+      def translate_matcher(matcher, rspec_matcher)
+        matcher[rspec_matcher.to_s].collect do |matcher_value|
+          translate_matcher_with_question(matcher_value, rspec_matcher)
+          alias_method matcher_value, rspec_matcher
+        end
+      end
+      
+      # Translate a method with the '?'
+      #
+      #
+      def translate_matcher_with_question(matcher_value, rspec_matcher)
+        Object.class_eval do
+          alias_method "#{matcher_value}?", "#{rspec_matcher}?" if MATCHERS_WITH_QUESTIONS.include?(rspec_matcher)
+        end
+      end
+      
     end
+    
   end
 end

data/lib/spec-i18n/parser/natural_language.rb

@@ -1,83 +1,284 @@
 module SpecI18n
   module Parser
     class NaturalLanguage
-      BASIC_KEYWORDS = %w{ name native describe before after it 
-                           subject its should should_not}
+      
+      BASIC_KEYWORDS = %w{ name native describe before after it pending subject 
+       shared_examples_for share_as it_should_behave_like its should should_not}
                               
-      ADVANCED_KEYWORDS = %w{ hooks matchers}
+      ADVANCED_KEYWORDS = %w{ hooks matchers }
       
-      class << self
-        def get(language)
-          new(language)
-        end        
+      def self.get(language)
+        new(language)
       end
 
       attr_reader :keywords
       
       def initialize(language)
-        @keywords = SpecI18n::SPEC_LANGUAGES[language]
+        raise(LanguageNilNotFound, "Language -> nil Not Found") unless language
+        @keywords = NaturalLanguage.find_language(language)
         raise(LanguageNotFound, "Language #{language.to_s} Not Supported") if @keywords.nil?
       end
       
+      # Find the language in languages.yml and return all the keywords
+      #
+      def self.find_language(language)
+        SpecI18n::SPEC_LANGUAGES[language]
+      end
+      
+      # Return true if the language don't have the basic keywords
+      # to work with rspec-i18n
+      #
+      # portuguese = NaturalLanguage.new('pt') # Assuming Have all the keywords
+      #
+      # portuguese.incomplete? # => false
+      #
       def incomplete?
         language_words = BASIC_KEYWORDS.collect { |key| keywords[key].nil? }
         return true if language_words.include?(true)
         false
       end
 
+      # Return the describe word in the languages.yml
+      # 
       def dsl_keywords
         spec_keywords("describe")
       end
-
+      
+      # Return the should and should_not words in the languages.yml
+      #
       def expectation_keywords
-        language_adverbs = spec_keywords("should")
-        language_adverbs.merge(spec_keywords("should_not"))
+        spec_keywords("should").merge(spec_keywords("should_not"))
       end
       
+      # Return the before and after words in the languages.yml
+      #
       def before_and_after_keywords
-        adverbs = spec_keywords("before")
-        adverbs.merge(spec_keywords("after"))
+        spec_keywords('before').merge(spec_keywords('after'))
+      end
+      
+      # Return All the Hooks in the languages.yml
+      # If not have hooks return a empty Hash
+      #
+      # The hooks in the rspec is the argument for before and after method
+      #
+      #           hook                hook
+      #             \                 /
+      #     before(:each)     after(:all)
+      #
+      def hooks
+        keywords['hooks'] || {}
       end
       
+      # Return all the hooks words in the languages.yml in a Hash of Arrays
+      #
       def hooks_params_keywords
-        hooks = {}
-        keywords['hooks'].each do |hook, value|
-          values = value.split('|')
-          hooks[hook] = values
+        hooks_keywords = {}
+        hooks.each do |hook, value|
+          values = split_word(value)
+          hooks_keywords[hook] = values
         end
-        hooks
+        hooks_keywords
       end
       
+      # Returns the combination of before and after with hooks keywords
+      #
+      #
+      def hooks_permutation
+        permutation = {}
+        before_and_after_keywords.each do |before_keyword, before_translated|
+          hooks.each do |hook_keyword, hook_translated|
+            words = split_word(hook_translated)
+            translation = words.collect { |word| before_translated.collect { |keyword| "#{keyword}(:#{word})" } }.flatten
+            permutation["#{before_keyword}(:#{hook_keyword})"] = translation
+          end
+        end
+        permutation
+      end
+      
+      # Return the it word in the languages.yml
+      #
       def example_group_keywords
         spec_keywords("it")
       end
 
+      # Return the subject word in the languages.yml
+      #
       def subject_keywords
         adverbs = spec_keywords('subject')
       end
 
+      # Return the its keywords in the languages.yml
+      #
       def its_keywords
         spec_keywords("its")
       end
       
+      # Return All the Matchers in the languages.yml
+      #
+      def matchers
+        keywords["matchers"] || {}
+      end
+      
+      # Return the shared examples for words in the languages.yml
+      #
+      def shared_examples_for_keywords
+        spec_keywords('shared_examples_for')
+      end
+      
+      # Return the share_as words in the languages.yml
+      #
+      def share_as_keywords
+        spec_keywords('share_as')
+      end
+      
+      # Return the it should behave like words in the languages.yml
+      #
+      def it_should_behave_like_keywords
+        spec_keywords('it_should_behave_like')
+      end
+      
+      # Return the pending words in the languages.yml
+      #
+      def pending_keywords
+        spec_keywords('pending')
+      end
+      
+      # Find the matcher and return the words in the languages.yml
+      #
+      # pt: matchers: equal: igual|igual_a
+      # NaturalLanguage.new('pt').find_matcher('equal') # => { 'equal' => ['igual', 'igual_a']}
+      #
+      def find_matcher(matcher)
+        matcher = matcher.to_s
+        matcher_and_values = {}        
+        matcher_and_values[matcher] = split_word(matchers[matcher])
+        matcher_and_values
+      end
+      
+      # Return the keywords of be_* matchers in the languages.yml
+      #
+      # pt: 
+      #   matchers: 
+      #     be: ser
+      #     true_word: verdadeiro|verdade
+      #
+      # NaturalLanguage.new('pt').word_be('true') # => ['ser_verdadeiro', 'ser_verdade']
+      #
       def word_be(ruby_type)
-        matchers_be = keywords['matchers']['be'].to_s.split("|")
-        matcher_ruby_type = keywords['matchers']["#{ruby_type}_word"].to_s.split("|")
-        matchers_be.collect do |matcher_be|
-          matcher_ruby_type.collect { |matcher| "#{matcher_be}_#{matcher}" }
-        end.flatten
+        ruby_type_matchers = matchers ? split_word(matchers["#{ruby_type}_word"]) : []
+        words = keywords_of_be_word.collect do |matcher_be|
+          invert_or_not_ruby_type_mathers(matcher_be, ruby_type_matchers)
+        end
+        words.flatten
       end
-
-      def spec_keywords(key, space=false)
-        raise "No #{key} in #{keywords.inspect}" if keywords[key].nil?
-        values = keywords[key].split('|')
+      
+      # Return the be words in the languages.yml
+      # If not have any matchers return a empty Array
+      #
+      def keywords_of_be_word
+        return split_word(matchers['be']) if matchers
+      end
+      
+      # Return true if the keyword has the '*' character in the last position
+      #
+      # de:
+      #   matchers:
+      #     true_word: wahr*
+      #
+      # @germany = NaturalLanguage.new('de')
+      # @germany.invert_order_of_object_and_verbs?(matchers['true_word']) # => true
+      #
+      # pt:
+      #  matchers:
+      #    true_word: verdadeiro
+      #
+      # @portuguese = NaturalLanguage.new('pt')
+      # @portuguese.invert_order_of_object_and_verbs?(matchers['true_word']) # => false
+      #
+      def invert_order_of_object_and_verbs?(keyword)
+        return true if keyword.to_s.include?('*')
+        false
+      end
+      
+      # PENDENCIA - SPEC THIS
+      #
+      def invert_or_not_ruby_type_mathers(matcher_be, ruby_type_matchers)
+        ruby_type_matchers.collect do |matcher|
+          if invert_order_of_object_and_verbs?(matcher) 
+            invert_order(:first => matcher, :second => matcher_be)
+          else
+            "#{matcher_be}_#{matcher}"
+          end
+        end
+      end
+      
+      def invert_order(options={})
+        options.each { |key, value| options[key] = value.delete('*') }
+        "#{options[:first]}_#{options[:second]}"
+      end
+      
+      # Return the values from keywords
+      #
+      # @pt.values_from_keywords('hooks') # => {'all'=>'todos','each'=>'cada'}
+      #
+      def values_from_keywords(keyword)
+        unless keywords[keyword]
+          {}
+        else
+          keywords[keyword]
+        end
+      end
+      
+      def basic_keywords
+        keywords.reject { |keyword, translated| include_in_advanced_keywords?(keyword) }
+      end
+      
+      def advanced_keywords
+        keywords.reject { |keyword, translated| not_include_in_advanced_keywords?(keyword) }
+      end
+      
+      # Return the words of languages.yml in a Hash with Array values
+      #
+      # pt:
+      #   describe: descreva|descrevendo
+      #
+      # NaturalLanguage.new('pt').spec_keywords('describe') # => { 'describe' => ['descreva', 'descrevendo']}
+      #
+      # fr:
+      # should:
+      #
+      # NaturalLanguage.new('fr').spec_keywords('should') # => { 'should' => [] } 
+      #
+      #
+      # NaturalLanguage.new('es').spec_keywords('key_not_found') # => RuntimeError: "No key_not_found in #{keywords}"
+      #
+      def spec_keywords(key)        
+        return { key => [] } unless keywords[key]
+        values = split_word(keywords[key])
         { key => values }
       end
+      
+      private
+      
+      def split_word(word)
+        word.to_s.split("|")
+      end
+      
+      def include_in_advanced_keywords?(keyword)
+        ADVANCED_KEYWORDS.include?(keyword)
+      end
+      
+      def not_include_in_advanced_keywords?(keyword)
+        !ADVANCED_KEYWORDS.include?(keyword)
+      end
 
     end
 
     class LanguageNotFound < StandardError
     end
+    
+    class LanguageNilNotFound < StandardError      
+    end
 
   end
 end