transdifflation 0.0.1 → 0.0.2

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.DS_Store
 Gemfile.lock
 InstalledFiles
 _yardoc

data/Fudgefile

@@ -1,4 +1,4 @@
 build :default do
   yard :arguments => '-r YardREADME.md', :coverage => 100
-  rspec :coverage => 96
+  rspec :coverage => 72
 end

data/Gemfile

@@ -10,6 +10,7 @@ group :development, :test do
   gem 'rspec'
   gem 'yard'
   gem 'simplecov'
+  gem 'rake'
 
   gem 'rspec-rails'
   gem 'guard-sass', :require => false

data/README.md

@@ -4,6 +4,8 @@ What is Transdifflation? Transdifflation is an acronym of 'Translation' and 'Dif
 It compares two .yml locate files, one in your source code (target) and one in others' (gems, other projects) source code (source) and generates a beside-file with the keys you hadn't translated yet.  
 Then you can merge it. It is designed to detect changes between versions. By now, target file cannot be renamed, and it is generated in 'config/locales/' + to_locale (param in task). Names are inferred by the task params too.
 
+Also, it has three new rake tasks to provide information to you about missing translations between two locales, and continuous integration support.
+
 IT NEVER CHANGES YOUR SOURCE FILE, unless it doesn't exists, so it creates for you. 
 
 ## Installation
@@ -22,7 +24,9 @@ Or install it yourself as:
 
 ## Usage
 
-It needs a config file (**transdifflation.yml**) placed on your host root, or in 'lib/tasks'. Config file looks like:
+### How to configure your Rake tasks
+
+It needs a config file (**transdifflation.yml**) placed on your host root, or in 'config'. If not exists, a rake task is set up to generate it: ```rake transdifflation:config```. Config file looks like:
 
 ```yml
 tasks:
@@ -58,9 +62,26 @@ These nodes generates rake tasks. There are two types of tasks:
 
 *   type **file**: When it rans, it looks for the file in 'file_path_from_rails_root' is installed. It uses from_locale and to_locale to translate names and keys inside yaml. Tag_name is used to name target file in our host.
 
-Execute ```rake transdifflation:config``` to determine sucess of config file.
+Also, you can create grouped tasks in a node called 'grouped_taks'. Task ```transdifflation:all``` is automatically generated.  
+
+Execute ```rake -T``` to determine sucess of config file. Your tasks should appear there, under namespace ```transdifflation:``
+
+
+### _'Out of the box'_ rake tasks
+
+There are two new tasks in the town:
+
+*   ```rake transdifflation:lost_in_translation[from_locale,to_locale]```
+*   ```rake transdifflation:lost_in_translation_ci[from_locale,to_locale]```
+*   ```rake transdifflation:coverage[from_locale,to_locale]```
+
+These tasks are intended to be used to know what keys are missing between two locales. ```rake transdifflation:lost_in_translation[from_locale,to_locale]``` creates a file in ```[Rails.root]/config/locales/[from_locale]/missing_translations.yml.diff```(on YAML format), that you can use as a template to fulfill your translation.
+
+```rake transdifflation:lost_in_translation_ci[from_locale,to_locale]``` doesn't create a file, it just fails if missing translations needed, so you can use it in a continuous integration environment, if you want to test that your translations are always completed between your third party gems' new versions, or other vendor's project new releases, or stuff like that...
+
+```rake transdifflation:coverage[from_locale,to_locale]``` gives you information and statistics of translations. 
+
 
-Also, you can create grouped tasks in a node called 'grouped_taks'. Task **all** is automatially generated.  
 
 
 ## Contributing

data/Rakefile

@@ -1,4 +1,5 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+Dir['lib/tasks/*'].each { |f| load f }
 RSpec::Core::RakeTask.new('spec')

data/lib/tasks/lost_in_translation.rake

@@ -0,0 +1,59 @@
+require 'rails'
+
+
+namespace :transdifflation do
+
+  def get_differences (from_locale, to_locale)
+
+    #this will access translations method, that is protected in BackEnd in I18n
+    translations = I18n.backend.send(:translations)
+    hash_from_locale = translations[from_locale]
+    hash_to_locale = translations[to_locale]
+
+    comparer = Transdifflation::Comparer.new
+    differences = comparer.get_rest_of_translation(hash_from_locale, hash_to_locale, from_locale, to_locale)
+    differences = { to_locale.to_s => differences } if !differences.empty?
+
+  end
+
+  desc "What is not translated in our app"
+  task :lost_in_translation, [:from_locale, :to_locale] => [:environment] do |t, args|
+
+
+    args.with_defaults(:from_locale => I18n.default_locale, :to_locale => I18n.locale)
+    puts "\nExecuting lost_in_translation ************************** "
+    from_locale = args[:from_locale].to_sym
+    to_locale = args[:to_locale].to_sym
+    differences = get_differences(from_locale, to_locale)
+
+    if !differences.empty?
+      missing_translations_file = File.join( Rails.root, "config/locales/#{to_locale}/missing_translations.yml.diff")
+      missing_translations_stream = File.new(missing_translations_file, "w+:UTF-8")
+      begin
+        missing_translations_stream.write("#These are the missing translations Transdifflation found for you\n")
+        missing_translations_stream.write(Transdifflation::YAMLWriter.to_yaml(differences))  #we can't use YAML#dump due to issues wuth Utf8 chars
+        puts "Detected missing translations, file '#{missing_translations_file}' has them:\n\n#{differences.to_yaml}" if !differences.empty?
+      ensure
+        missing_translations_stream.close
+      end
+
+    else
+      puts "Sucess! All translation are done!"
+    end
+  end
+
+  desc "Testing in CI what is not translated in our app"
+  task :lost_in_translation_ci, [:from_locale, :to_locale] => [:environment] do |t, args|
+
+    args.with_defaults(:from_locale => I18n.default_locale, :to_locale => I18n.locale)
+    puts "\nExecuting lost_in_translation_ci ************************** "
+
+    differences = get_differences(args[:from_locale].to_sym, args[:to_locale].to_sym)
+    fail "Detected missing translations: \n\n#{differences.to_yaml}" if !differences.empty?
+    puts "Sucess! All translation are done!"
+
+  end
+
+
+
+end

data/lib/tasks/translation_coverage.rake

@@ -0,0 +1,33 @@
+require 'rails'
+
+
+namespace :transdifflation do
+
+  def get_coverage_rate(from_locale, to_locale)
+    #this will access translations method, that is protected in BackEnd in I18n
+    translations = I18n.backend.send(:translations)
+    hash_from_locale = translations[from_locale]
+    hash_to_locale = translations[to_locale]
+
+    comparer = Transdifflation::Comparer.new
+    comparer.coverage_rate(hash_from_locale, hash_to_locale)
+
+  end
+
+  desc "A task to check a translation coverage"
+  task :coverage, [:from_locale, :to_locale] => [:environment] do |t, args|
+
+    args.with_defaults(:from_locale => I18n.default_locale, :to_locale => I18n.locale)
+    puts "\nChecking how much work you have left...\n"
+    from_locale = args[:from_locale].to_sym
+    to_locale = args[:to_locale].to_sym
+    #token = args[:token]
+
+    differences = get_coverage_rate(from_locale, to_locale)
+    puts "You have #{differences}"
+
+  end
+
+
+
+end

data/lib/transdifflation.rb

@@ -4,6 +4,8 @@ require 'transdifflation/yaml_writer'
 require 'transdifflation/exceptions'
 require 'transdifflation/utilities'
 
+require 'pry'
+
 # The main module for the program
 module Transdifflation
 
@@ -30,8 +32,9 @@ module Transdifflation
     def get_transdifflation_from_gem(gem_name, path_to_yaml_in_gem, from_locale=:en, to_locale=:es )
 
       #default values in optional params
-      from_locale ||= :en
-      to_locale ||= :es   #sorry, this gem was developed in Spain :)
+      from_locale ||= I18n.default_locale
+      to_locale ||= I18n.locale
+
 
       yml_gem_content = YAMLReader.read_YAML_from_gem(gem_name, path_to_yaml_in_gem)
       puts "Loaded YAML content from gem '#{gem_name}', file '#{path_to_yaml_in_gem}'"
@@ -64,8 +67,8 @@ module Transdifflation
     def get_transdifflation_from_file(tag_name, path_to_yaml_relative_from_rails_root, from_locale=:en, to_locale=:es )
 
       #default values in optional params
-      from_locale ||= :en
-      to_locale ||= :es   #sorry, this gem was developed in Spain :)
+      from_locale ||= I18n.default_locale
+      to_locale ||= I18n.locale
 
       yml_source_content = YAMLReader.read_YAML_from_pathfile(path_to_yaml_relative_from_rails_root)
       puts "Loaded YAML content from file '#{path_to_yaml_relative_from_rails_root}'"
@@ -87,10 +90,77 @@ module Transdifflation
     end
 
 
+    # Get Diff from YAML translation locale file from filesystem and generate differences in a file on our host
+    #
+    # @param [String] source I18n source translation to compare
+    # @param [String] target I18n target translation to compare
+    # @param [Symbol] from_locale Default locale in gem. Used to translate 'from'
+    # @param [Symbol] to_locale   Default locale in host. Used to translate 'to'
+    def get_rest_of_translation(source, target, from_locale, to_locale)
+
+      added_diff_hash = {}
+      generate_added_diff(source, target, added_diff_hash, Array.new,  from_locale, to_locale, false)
+      added_diff_hash.unsymbolize!
+    end
+
+
+    # Get Coverage rate from two hashes, depending on the number of keys that have a given token
+    #
+    # @param [Hash] hash_from_locale I18n source translation to compare
+    # @param [Hash] hash_to_locale I18n target translation to compare
+    # @param [String] token The string you want to compare. example: **NOT TRANSLATED**
+    def coverage_rate(hash_from_locale, hash_to_locale, token = NOT_TRANSLATED)      
+        
+      if hash_from_locale.nil?
+        return "Translation coverage error: from_locale language not detected."
+      end
 
+      if hash_to_locale.nil?
+        return "Translation coverage error: to_locale language not detected."
+      end
+      
+      if hash_from_locale.empty?
+        return "from_locale is empty, so you have everything translated"         
+      end
+
+      words = 0
+      found = 0
 
+      words, found = rate_from_branch(hash_from_locale, hash_to_locale, token, words, found)
+      percent = (found.to_f/words.to_f) * 100
+      truncate = "%.2f" % percent
+      return "#{truncate}% #{found}/#{words} entries translated"
+    end
 
 
+    # Get the number of translated keys 
+    #
+    # @param [Hash] hash_from I18n source translation to compare
+    # @param [Hash] hash_to I18n target translation to compare
+    # @param [String] token The string you want to compare. example: **NOT TRANSLATED**
+    # @param [Integer] words Number of keys (accumulated) from hash_from
+    # @param [Integer] found Number of keys (accumulated) where token is not found in hash_to 
+    def rate_from_branch(hash_from, hash_to, token, words, found)
+
+      hash_from.each_pair{ |key, value|
+        if hash_from[key.to_sym].instance_of? Hash
+          if hash_to[key.to_sym]
+            words, found = rate_from_branch(hash_from[key.to_sym], hash_to[key.to_sym], token, words, found)
+          else
+          # Sum other words
+          # could have nested branches, so we call it with hash_from[key.to_sym] to count the number of words, returning the found to a temporal var
+          words, temp = rate_from_branch(hash_from[key.to_sym], hash_from[key.to_sym], token, words, found)
+          end
+        else
+          words += 1
+          if hash_to[key.to_sym]
+            found += 1 if !hash_to[key.to_sym].to_s.include?(token) 
+          end          
+        end
+      }
+      return words, found
+    end      
+
     private
 
     # Build the initial translation file
@@ -102,12 +172,10 @@ module Transdifflation
     def get_first_time_file(yml_source_content, host_target_file, from_locale, to_locale)
 
       puts "Target translation file '#{host_target_file}' not found, generating it for the first time"
-
       #create a file
       host_target_file_stream = File.open(host_target_file, "a+:UTF-8")
 
       begin
-
         translated_yaml = {}
         #translate from source yaml content, to target existant yml
         translate_keys_in_same_yaml(yml_source_content, translated_yaml, from_locale, to_locale)
@@ -115,10 +183,8 @@ module Transdifflation
         host_target_file_stream.write(YAMLWriter.to_yaml(translated_yaml))
         @has_changes = true
       ensure
-
         host_target_file_stream.close
       end
-
     end
 
 
@@ -140,13 +206,10 @@ module Transdifflation
 
         #if value is a hash, we call it recursively
         if (source_value.instance_of? Hash)
-
           if(!target.has_key? (source_key_translated))
             target[source_key_translated] = Hash.new
           end
-
           translate_keys_in_same_yaml(source_value, target[source_key_translated], from_locale, to_locale, add_NOT_TRANSLATED) #recurrence of other hashes
-
         else
           #it's a leaf node
           target[source_key_translated] = (add_NOT_TRANSLATED ? "#{NOT_TRANSLATED}#{source_value}" : "#{source_value}") if  !target.has_key? (source_key_translated)
@@ -176,7 +239,7 @@ module Transdifflation
         diff_file = File.join(File.dirname(host_target_file), "#{File.basename(host_target_file)}.diff")
         diff_file_stream = File.new(diff_file, "w+:UTF-8")
         begin
-
+           
           if (added_diff_hash.length > 0)
             diff_file_stream.write("ADDED KEYS (Keys not found in your file, founded in source file) ********************\n")
             diff_file_stream.write(YAMLWriter.to_yaml(added_diff_hash))  #we can't use YAML#dump due to issues wuth Utf8 chars
@@ -221,7 +284,7 @@ module Transdifflation
         if (source_value.instance_of? Hash)
           key_trace.push source_key_translated #add the key to the trace to be generated if necessary
           target[source_key_translated] = Hash.new if(!target.has_key? (source_key_translated))  #to continue trace, otherwise, node will not exist in next iteration
-          generate_added_diff(source_value, target[source_key_translated], added_diff_hash, key_trace, from_locale, to_locale) #recursively call
+          generate_added_diff(source_value, target[source_key_translated], added_diff_hash, key_trace, from_locale, to_locale, add_NOT_TRANSLATED) #recursively call
         else #it's a leaf node
 
           if !target.has_key? (source_key_translated)
@@ -236,13 +299,8 @@ module Transdifflation
       }
     end
 
-   
-
-
-
     def self.generate_config_example_file(path)
       FileUtils.copy(File.expand_path('./transdifflation/transdifflation.yml', File.dirname( __FILE__ )), path)
     end
-
   end
 end

data/lib/transdifflation/railtie.rb

@@ -1,15 +1,22 @@
-require 'transdifflation'
 require 'rails'
+require 'transdifflation'
+
+
+
+
+
 
 module Transdifflation
 
   # Adds behaviours to Rails
   class Railtie < Rails::Railtie
     search_locations = %w[config/transdifflation.yml transdifflation.yml]
-
     railtie_name :transdifflation
     rake_tasks do
       begin
+        
+        Dir[ File.join(File.dirname(__FILE__), '../tasks/*.rake')] .each { |f| load f }  #Load static tasks
+
 
         file_task_config = nil
         search_locations.each do |path| #Take config file from these locations
@@ -91,7 +98,6 @@ module Transdifflation
         end
 
       rescue Transdifflation::ConfigFileNotFound
-       
         #Generate task to set-up 
         namespace :transdifflation do
           desc "Task to set-up config file in host"

data/lib/transdifflation/utilities.rb

@@ -4,7 +4,7 @@ module Transdifflation
 
   #Class used to convert all keys in a hash (included sub-hashes) in symbols
   class HashSymbolTranslator
-    # Convert keys
+    # Convert keys (strings) into symbols
     def symbolize(hash)
       hash = hash.inject({}) { |memo,(k,v)| 
           if(v.instance_of? Hash)
@@ -15,6 +15,19 @@ module Transdifflation
       }
       hash
     end
+     # Convert keys into string
+     def unsymbolize(hash)
+      hash = hash.inject({}) { |memo,(k,v)| 
+          if(v.instance_of? Hash)
+             v = unsymbolize(v)
+          end 
+          memo[k.to_s] = v
+          memo
+      }
+      hash
+    end
+
+
   end
 end
 
@@ -28,4 +41,12 @@ class Hash
     self.merge!(new_self)
   end
 
+  #convert all keys in a Hash (presumily from YAML) in symbols
+  def unsymbolize!
+    symbolizer = Transdifflation::HashSymbolTranslator.new
+    new_self = symbolizer.unsymbolize(self)
+    self.clear
+    self.merge!(new_self)
+  end
+
 end

data/lib/transdifflation/version.rb

@@ -1,4 +1,4 @@
 module Transdifflation
   # Gem version
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/transdifflation/yaml_reader.rb

@@ -18,7 +18,6 @@ module Transdifflation
 
       #read the yml content file
       get_YAML_content_from_YAML_file(yaml_file_in_gem_SRC)
-     
     end
 
     # Get YAML content from a file in filesystem
@@ -33,7 +32,6 @@ module Transdifflation
 
       #read the yml content file
       get_YAML_content_from_YAML_file(yaml_file_path)
-     
     end
 
     # Get YAML content from a file in filesystem
@@ -46,7 +44,7 @@ module Transdifflation
       raise ArgumentError.new("File '#{yaml_file_name}' does not exists in path '#{path_to_yaml}'") if (!File.file?(path_to_yaml))
 
       #read the yml content file
-      get_YAML_content_from_YAML_file(path_to_yaml)     
+      get_YAML_content_from_YAML_file(path_to_yaml)
     end
 
     private

data/lib/transdifflation/yaml_writer.rb

@@ -8,7 +8,7 @@ module Transdifflation
       method = hash.respond_to?(:ya2yaml) ? :ya2yaml : :to_yaml
       string = hash.deep_stringify_keys.send(method)
       yaml_string = string.gsub("!ruby/symbol ", ":").sub("---","")
-      yaml_string = yaml_string.gsub(/(\?) "([\w\s\\]+)"\n/) do |match|
+      yaml_string = yaml_string.gsub(/(\?) "([\w\s\\]+)"\n/) do |match| #Regex ? "es" \n
         match.sub(/\?\s+/, "").chomp
       end
       yaml_string = yaml_string.split("\n").map(&:rstrip).join("\n").strip

data/spec/assets/testfile

@@ -0,0 +1,7 @@
+ADDED KEYS (Keys not found in your file, founded in source file) ********************
+:es:
+  :home: ! '**NOT_TRANSLATED** hogar'
+
+REMOVED KEYS (Keys not found in source file, founded in your file) ********************
+:es:
+  :dorothy: Dorothy

data/spec/coverage_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'transdifflation'
+
+describe :translation_coverage do
+	describe :coverage_rate do
+		it 'should return a message when hash_from_locale is an nil hash' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = nil
+			hash_to_locale  = {}
+			token = "**NOT TRANSLATED**"
+			
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "Translation coverage error: from_locale language not detected."
+		end
+		it 'should return a message when hash_to_locale is an nil hash' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = {}
+			hash_to_locale  = nil
+			token = "**NOT TRANSLATED**"
+			
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "Translation coverage error: to_locale language not detected."
+		end
+
+		it 'should return 100% when hash_from_locale is empty' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = {}
+			hash_to_locale  = {}
+			token = "**NOT TRANSLATED**"
+			
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "from_locale is empty, so you have everything translated"
+		end
+
+		it 'should return 100% when hash_from_locale is empty, even if there is something at hash_to_locale' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = {}
+			hash_to_locale  = {:home => "hogar"}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "from_locale is empty, so you have everything translated"
+		end
+
+		it 'should return 0% when theres all to translate' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = {:home => "home"}
+			hash_to_locale  = {}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "0.00% 0/1 entries translated"
+		end
+
+		it 'should return 100% when you have everything translated (5/5)' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :one => "one", :two => "two", :three => "tree", :four => "four", :five => "five" }
+			hash_to_locale =   { :one => "uno", :two => "dos", :three => "tres", :four => "cuatro", :five => "cinco" }
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "100.00% 5/5 entries translated"
+		end
+
+		it 'should return 80% when you have 8/10 terms translated' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :one => "one", :two => "two", :three => "tree", :four => "four", :five => "five", :six => "six", :seven => "seven", :eight => "eight", :nine => "nine", :ten => "ten" }
+			hash_to_locale =   { :one => "uno", :two => "dos", :three => "tres", :four => "cuatro", :five => "cinco", :six => "**NOT TRANSLATED** six", :seven => "**NOT TRANSLATED** seven", :eight => "ocho", :nine => "nueve", :ten => "diez" }
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "80.00% 8/10 entries translated"
+		end
+
+
+		it 'should return 70% when you have 7/10 terms translated, but you dont have a term, even in the hash and 2 of them are not translated' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :one => "one", :two => "two", :three => "tree", :four => "four", :five => "five", :six => "six", :seven => "seven", :eight => "eight", :nine => "nine", :ten => "ten" }
+			hash_to_locale =   { :one => "uno", :two => "dos", :three => "tres", :four => "cuatro", :five => "cinco", :six => "**NOT TRANSLATED** six", :seven => "**NOT TRANSLATED** seven", :eight => "ocho", :nine => "nueve" }
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "70.00% 7/10 entries translated"
+		end
+
+		it 'should return 62.50% when you have 5/8 terms translated' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :one => "one", :two => "two", :three => "tree", :four => "four", :five => "five", :six => "six", :seven => "seven", :eight => "eight" }
+			hash_to_locale =   { :one => "uno", :two => "**NOT TRANSLATED** two", :three => "tres", :four => "cuatro", :five => "cinco", :six => "**NOT TRANSLATED** six", :seven => "**NOT TRANSLATED** seven", :eight => "ocho"}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "62.50% 5/8 entries translated"
+		end
+
+		it 'should return 62.50% when you have 5/8 terms translated, having extra terms at the hash_to_locale hash' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :one => "one", :two => "two", :three => "tree", :four => "four", :five => "five", :six => "six", :seven => "seven", :eight => "eight" }
+			hash_to_locale =   { :one => "uno", :two => "**NOT TRANSLATED** two", :three => "tres", :four => "cuatro", :five => "cinco", :six => "**NOT TRANSLATED** six", :seven => "**NOT TRANSLATED** seven", :eight => "ocho", :puerta => "Puerta"}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "62.50% 5/8 entries translated"
+		end
+
+		it 'should return 100.00% in nested hash' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :house => "house", :street => {:street_name => "street name", :postal => "postal code"}}
+			hash_to_locale = { :house => "casa", :street => {:street_name => "Nombre de la calle", :postal => "codigo postal"}}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "100.00% 3/3 entries translated"
+		end
+
+		it 'should return 3 entries, 2 translations found' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :house => "house", :street => {:street_name => "street name", :postal => "postal code"}}
+			hash_to_locale = { :house => "casa", :street => {:street_name => "**NOT TRANSLATED** Nombre de la calle", :postal => "codigo postal"}}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "66.67% 2/3 entries translated"
+		end
+
+		it 'should return 0.00% in nested hash' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :street => {:street_name => "**NOT TRANSLATED** Nombre de la calle", :postal => "codigo postal", :number => { :one => "one", :two => "two", :three => "tree"}}}
+			hash_to_locale =   { :one => "uno"}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "0.00% 0/5 entries translated"
+		end
+
+		it 'should return 10.00% in nested hash' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :one => "one", :two => "two", :three => "tree", :four => "four", :five => "five", :six => "six", :seven => "seven", :eight => "eight", :nine => "nine", :ten => "ten", :street => {:street_name => "**NOT TRANSLATED** Nombre de la calle", :postal => "codigo postal"}}
+			hash_to_locale =   { :one => "uno"}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "8.33% 1/12 entries translated"
+		end
+
+		it 'should return 8.33% in nested hash with only one term' do
+			@comparer = Transdifflation::Comparer.new
+			hash_from_locale = { :one => "one", :two => "two", :three => "tree", :four => "four", :five => "five", :six => "six", :seven => "seven", :eight => "eight", :nine => "nine", :ten => "ten", :street => {:street_name => "Nombre de la calle", :postal => "codigo postal"}}
+			hash_to_locale =   { :one => "uno"}
+			token = "**NOT TRANSLATED**"
+
+			@comparer.coverage_rate(hash_from_locale, hash_to_locale, token).should == "8.33% 1/12 entries translated"
+		end
+	end
+end

data/spec/lost_in_translation_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'transdifflation'
+
+describe :lost_in_translation do
+
+	before (:each) do
+		@comparer = Transdifflation::Comparer.new
+	end
+
+	describe :inner_functionallity do
+		it 'should return no differences with same data' do
+			i18n = { :es => {:one_key => 'uno', :another_key => 'dos'} }
+			@comparer.get_rest_of_translation(i18n, i18n, :es, :es).should eql({})
+		end
+
+		it 'should return differences with different data' do
+			i18n_en = { :en => {:one_key => 'one', :another_key => 'another', :another_one => 'another_one_even'} }
+			i18n_es = { :es => {:one_key => 'uno', :another_key => 'dos'} }
+			@comparer.get_rest_of_translation(i18n_en, i18n_es, :en, :es).should eql( {"es" => {"another_one" => "another_one_even" }} )
+		end
+
+		it 'should return no differences if target has more info than source' do
+			i18n_en = { :en => {:one_key => 'one', :another_key => 'another'} }
+			i18n_es = { :es => {:one_key => 'uno', :another_key => 'dos', :another_one => 'tres'} }
+			@comparer.get_rest_of_translation(i18n_en, i18n_es, :en, :es).should eql({})
+		end
+	end
+end

data/spec/transdifflation_spec.rb

@@ -1,20 +1,274 @@
-# require 'spec_helper'
-# require 'transdifflation' 
+require 'spec_helper'
+require_relative "../lib/transdifflation"
 
-#describe :get_transdifflation_from_gem do
-#  it 'convert a key in a Hash (presumily from YAML) in symbol' do
-#    gem_name = 'rake'
-#    path_to_yaml_in_gem = '.'
-#    from_locale= :en
-#    to_locale = :es
-#    Transdifflation::Comparer 
-#  end
-#  xit 'another test' do
+describe :get_transdifflation_from_gem do
 
+  before(:each) do
+    unless defined?(::Rails)
+      @mocked_rails_class = true
+      class ::Rails
+      end
+    end
 
-# end
+    @gem_name = 'rake'
+    @path_to_yaml_in_gem = 'spec/spec_helper.rb'
+    @from_locale= :en
+    @to_locale = :es
 
+    @comparer = Transdifflation::Comparer.new
 
+    #YAMLReader should returnb a valid hash
+    Transdifflation::YAMLReader.stub(:read_YAML_from_gem).and_return({es: {:home => "hogar"}})
+
+    #We require to simulate "Rails.root"
+    ::Rails.stub(:root).and_return('/rails')
+  end
+
+  it 'should call get_first_time_file if the files does not exist' do
+
+
+    #We actually don't care about basename, and we want to generate a testfile in our tests
+    File.stub(:basename).and_return('/dir/file_or_something')
+    File.stub(:join).and_return(File.join(File.dirname(__FILE__), '/assets/testfile'))
+
+    File.stub(:gsub).and_return('idontcare')
+
+    #File? Should return false, to simulate that the file is not created
+    File.stub(:file?).and_return(false)
+
+    @comparer = Transdifflation::Comparer.new
+    # And finally we are checking which method is being called, making them throw different exceptions
+    @comparer.stub(:get_first_time_file).and_raise(ArgumentError)
+    @comparer.stub(:generate_diff_file).and_raise(NameError)
+    @comparer.should_receive(:get_first_time_file)
+
+    expect {@comparer.get_transdifflation_from_gem(@gem_name, @path_to_yaml_in_gem, @from_locale, @to_locale) }.to raise_error(ArgumentError)
+  end
+
+  it 'should call generate_diff_file if the files exists' do
+
+    #We actually don't care about basename, and we want to generate a testfile in our tests
+    File.stub(:basename).and_return('/dir/file_or_something')
+    File.stub(:join).and_return(File.join(File.dirname(__FILE__), '/assets/testfile'))
+
+    File.stub(:gsub).and_return('idontcare')
+
+    #File? Should return true, to simulate that the file is exists
+    File.stub(:file?).and_return(true)
+
+    # And finally we are checking which method is being called, making them throw different exceptions
+    @comparer.stub(:get_first_time_file).and_raise(ArgumentError)
+    @comparer.stub(:generate_diff_file).and_raise(NameError)
+    @comparer.should_receive(:generate_diff_file)
+
+    expect {@comparer.get_transdifflation_from_gem(@gem_name, @path_to_yaml_in_gem, @from_locale, @to_locale) }.to raise_error(NameError)
+  end
+
+  it 'should translate yaml name from source locale to target locale' do
+
+    @path_to_yaml_in_gem = 'config/locales/en/gem_name.en.yml'  #source file, it has to be translated, and match inner reg exp
+
+    #File? Should return true, to simulate that the file is exists
+    File.stub(:file?).and_return(true)
+    #Finally simulate the call to generate_diff_file
+    @comparer.stub(:generate_diff_file).and_return(nil)
+
+
+
+
+
+    #call to method
+    expect { @comparer.get_transdifflation_from_gem(@gem_name, @path_to_yaml_in_gem, @from_locale, @to_locale) }.to_not raise_error
+  end
+
+end
+
+describe :get_transdifflation_from_file do
+
+  before(:each) do
+    unless defined?(::Rails)
+      @mocked_rails_class = true
+      class ::Rails
+      end
+    end
+
+    @tag_name = 'my_tag'
+    @path_to_yaml_relative_from_rails_root = 'spec/spec_helper.rb'
+    @from_locale= :en
+    @to_locale = :es
+
+    @comparer = Transdifflation::Comparer.new
+
+    #YAMLReader should returnb a valid hash
+    Transdifflation::YAMLReader.stub(:read_YAML_from_pathfile).and_return({es: {:home => "hogar"}})
+
+    #We require to simulate "Rails.root"
+    ::Rails.stub(:root).and_return('/rails')
+
+  end
+
+  it 'should call get_first_time_file if the files does not exist' do
+
+
+    #We actually don't care about basename, and we want to generate a testfile in our tests
+    File.stub(:basename).and_return('/dir/file_or_something')
+    File.stub(:join).and_return('./spec/assets/testfile_path')
+    #We require to simulate "Rails.root"
+    ::Rails.should_receive(:root).and_return('/rails')
+    File.stub(:gsub).and_return('idontcare')
+    #File? Should return false, to simulate that the file is not created
+    File.stub(:file?).and_return(false)
+
+    # And finally we are checking which method is being called, making them throw different exceptions
+    @comparer.stub(:get_first_time_file).and_raise(ArgumentError)
+    @comparer.stub(:generate_diff_file).and_raise(NameError)
+    @comparer.should_receive(:get_first_time_file)
+    expect { @comparer.get_transdifflation_from_file(@tag_name, @path_to_yaml_relative_from_rails_root, @from_locale, @to_locale) }.to raise_error(ArgumentError)
+  end
+
+  it 'should call generate_diff_file if the files exists' do
+
+    #We actually don't care about basename, and we want to generate a testfile in our tests
+    File.stub(:basename).and_return('/dir/file_or_something')
+    File.stub(:join).and_return('./spec/assets/testfile')
+    #We require to simulate "Rails.root"
+    ::Rails.should_receive(:root).and_return('/rails')
+    File.stub(:gsub).and_return('idontcare')
+    #File? Should return false, to simulate that the file is not created
+    File.stub(:file?).and_return(true)
+
+    # And finally we are checking which method is being called, making them throw different exceptions
+    @comparer.stub(:get_first_time_file).and_raise(ArgumentError)
+    @comparer.stub(:generate_diff_file).and_raise(NameError)
+    @comparer.should_receive(:generate_diff_file)
+    expect { @comparer.get_transdifflation_from_file(@tag_name, @path_to_yaml_relative_from_rails_root, @from_locale, @to_locale) }.to raise_error(NameError)
+  end
+
+  it 'should translate yaml name from source locale to target locale' do
+
+    @path_to_yaml_relative_from_rails_root = '../config/locales/en/file_name.en.yml'  #source file, it has to be translated, and match inner reg exp
+
+    #File? Should return true, to simulate that the file is exists
+    File.stub(:join).and_return('idontcare')
+    File.stub(:file?).and_return(true)
+    #Finally simulate the call to generate_diff_file
+    @comparer.stub(:generate_diff_file).and_return(nil)
+
+
+
+    #call to method
+    expect { @comparer.get_transdifflation_from_file(@tag_name, @path_to_yaml_relative_from_rails_root, @from_locale, @to_locale) }.to_not raise_error
+  end
+
+end
+
+
+describe :comparer_common_methods do
+
+  before(:each) do
+    unless defined?(::Rails)
+      @mocked_rails_class = true
+      class ::Rails
+      end
+    end
+
+    @gem_name = 'rake'
+    @path_to_yaml_in_gem = 'spec/spec_helper.rb'
+    @from_locale= :en
+    @to_locale = :es
+
+    @comparer = Transdifflation::Comparer.new
+
+    #YAMLReader should returnb a valid hash
+    Transdifflation::YAMLReader.stub(:read_YAML_from_gem).and_return({en: {:home => "hogar"}})
+
+
+    #We require to simulate "Rails.root"
+    ::Rails.stub(:root).and_return('/rails')
+  end
+
+  it 'should generate first timefile if the files does not exist' do
+
+
+    #We actually don't care about basename, and we want to generate a testfile in our tests
+    File.stub(:basename).and_return('config/locales/en/gem_name.en.yml')
+
+
+    #File? Should return false, to simulate that the file is not created
+    File.stub(:file?).and_return(false)
+
+
+    #now we must stub File.open, write and close in order to avoid fails on get_first_time_file
+    mock_file = mock("File")
+    mock_file.stub(:write).and_return(nil)
+    mock_file.stub(:close).and_return(nil)
+    File.stub(:open).and_return(mock_file)
+
+
+    expect {@comparer.get_transdifflation_from_gem(@gem_name, @path_to_yaml_in_gem, @from_locale, @to_locale) }.to_not raise_error
+  end
+
+  it 'should try to copy config_example_file if asked' do
+
+    FileUtils.stub(:copy).and_return(nil)
+    expect { Transdifflation::Comparer.generate_config_example_file('foo/bar') }.to_not raise_error
+  end
+
+  it 'should generate a valid diff_file when differences not exists' do
+
+    #We actually don't care about basename, and we want to generate a testfile in our tests
+    File.stub(:basename).and_return('/dir/file_or_something')
+    File.stub(:join).and_return('./spec/assets/testfile')
+    #We require to simulate "Rails.root"
+    ::Rails.should_receive(:root).and_return('/rails')
+    File.stub(:gsub).and_return('idontcare')
+    #File? Should return false, to simulate that the file is not created
+    File.stub(:file?).and_return(true)
+
+
+    #YAMLReader should return TWO valid hashes
+    Transdifflation::YAMLReader.stub(:read_YAML_from_pathfile).and_return( {es: {:dorothy => "Dorothy"}})
+
+    #now we must stub File.open, write and close in order to avoid fails on get_first_time_file
+    mock_file = mock("File")
+    mock_file.stub(:write).and_return(nil)
+    mock_file.stub(:close).and_return(nil)
+    File.stub(:open).and_return(mock_file)
+
+
+    expect { @comparer.get_transdifflation_from_gem(@gem_name, @path_to_yaml_in_gem, @from_locale, @to_locale) }.to_not raise_error
+
+
+  end
+
+  it 'should generate a clear diff_file when differences exists' do
+
+    #We actually don't care about basename, and we want to generate a testfile in our tests
+    File.stub(:basename).and_return('/dir/file_or_something')
+    File.stub(:join).and_return('./spec/assets/testfile')
+    #We require to simulate "Rails.root"
+    ::Rails.should_receive(:root).and_return('/rails')
+    File.stub(:gsub).and_return('idontcare')
+    #File? Should return false, to simulate that the file is not created
+    File.stub(:file?).and_return(true)
+
+   
+    #now we must stub File.open, write and close in order to avoid fails on get_first_time_file
+    mock_file = mock("File")
+    mock_file.stub(:write).and_return(nil)
+    mock_file.stub(:close).and_return(nil)
+    File.stub(:open).and_return(mock_file)
+
+    #YAMLReader should return TWO valid hashes
+    Transdifflation::YAMLReader.stub(:read_YAML_from_pathfile).and_return({en: {:home => "hogar"}})
+
+
+    expect { @comparer.get_transdifflation_from_gem(@gem_name, @path_to_yaml_in_gem, @from_locale, @from_locale) }.to_not raise_error
+
+
+  end
+
+
+end
 
 
-# end

data/spec/utilities_spec.rb

@@ -10,18 +10,25 @@ describe :symbolize! do
   it 'convert all keys in a Hash (presumily from YAML) in symbols' do
     example_hash = { "es" => 666, "lala" => "truururur" }
     example_hash.symbolize!
-	example_hash.should ==  { :es => 666, :lala => "truururur" }
+	 example_hash.should ==  { :es => 666, :lala => "truururur" }
   end
 
   it 'convert all keys in a Hash (presumily from YAML) in symbols but if there is a hash it should leave it' do
     example_hash = { :es => 666, "lala" => "truururur" }
     example_hash.symbolize!
-	example_hash.should ==  { :es => 666, :lala => "truururur" }
+	 example_hash.should ==  { :es => 666, :lala => "truururur" }
   end
 
   it 'should return something usefull on nil' do
     example_hash = Hash.new
     example_hash.symbolize!
-	example_hash.should ==  {}
+    example_hash.should ==  {}
+  end
+
+  it 'should call itself recursively' do
+    example_hash = { :es => 666, "lala" => "truururur", :nested => {:another => "Call for simbolize"}}
+    hash_translator = Transdifflation::HashSymbolTranslator.new
+    hash_translator.symbolize(example_hash)
+    example_hash.should ==  { :es => 666, "lala" => "truururur", :nested => {:another => "Call for simbolize"}}
   end
 end

data/spec/yaml_reader_spec.rb

@@ -26,6 +26,7 @@ describe :YAMLReader do
       File.stub(:file?).and_return(true)
       ::Rails.should_receive(:root).and_return('/rails')
 
+      
       expect {Transdifflation::YAMLReader.read_YAML_from_filesystem('whatever')}.to_not raise_error(ArgumentError)
     end
   end
@@ -84,4 +85,4 @@ describe :YAMLReader do
     end
   end
 
-end
+end

data/spec/yaml_writer_spec.rb

@@ -12,6 +12,14 @@ describe :YAMLWriter do
       hashy = {:movie => "Avengers"}
       Transdifflation::YAMLWriter.to_yaml(hashy).should be == ":movie: Avengers"
     end
+
+    it 'should chomp if matches with the regex: /\?\s+/' do
+      hashy = {:movie => "Avengers"}
+      Regex = "!ruby/symbol ---? \"es\"\n"   
+      hashy.deep_stringify_keys.stub(:send).and_return(Regex)
+
+      Transdifflation::YAMLWriter.to_yaml(hashy).should be == ":\"es\""
+    end
   end
 
   describe :deep_stringify_keys do
@@ -19,6 +27,12 @@ describe :YAMLWriter do
      hashy = {:en=>{:date=>{:formats=>{:default=>"%d/%m/%Y", :short=>"%d %b"}}}}
      hashy.deep_stringify_keys.should == {:en=>{:date=>{:formats=>{:default=>"%d/%m/%Y", :short=>"%d %b"}}}}
     end
+    
+    it 'should print all the nodes from a hash in the exact same order' do
+     hashy = {:en=>{:date=>{:formats=>{:default=>"%d/%m/%Y", :short=>"%d %b"}}}}
+     hashy.deep_stringify_keys.should == hashy
+    end
+
     it 'should print all the nodes from a hash in the exact same order' do
      hashy = {:en=>{:date=>{:formats=>{:default=>"%d/%m/%Y", :short=>"%d %b"}}}}
      hashy.deep_stringify_keys.should == hashy

data/transdifflation.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "transdifflation"
   gem.require_paths = ["lib"]
-  gem.version       = "0.0.1"
+  gem.version       = Transdifflation::VERSION
 
   #Dependencies
   gem.add_dependency 'rails', '~> 3.2.8'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: transdifflation
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-11 00:00:00.000000000 Z
+date: 2012-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -185,6 +185,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/tasks/lost_in_translation.rake
+- lib/tasks/translation_coverage.rake
 - lib/transdifflation.rb
 - lib/transdifflation/exceptions.rb
 - lib/transdifflation/railtie.rb
@@ -193,6 +195,9 @@ files:
 - lib/transdifflation/version.rb
 - lib/transdifflation/yaml_reader.rb
 - lib/transdifflation/yaml_writer.rb
+- spec/assets/testfile
+- spec/coverage_spec.rb
+- spec/lost_in_translation_spec.rb
 - spec/spec_helper.rb
 - spec/transdifflation_spec.rb
 - spec/utilities_spec.rb
@@ -225,6 +230,9 @@ specification_version: 3
 summary: Compares yml locate files with yours and generate diff files to maintain
   gems or adjacent projects
 test_files:
+- spec/assets/testfile
+- spec/coverage_spec.rb
+- spec/lost_in_translation_spec.rb
 - spec/spec_helper.rb
 - spec/transdifflation_spec.rb
 - spec/utilities_spec.rb