bisu 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90f92046e9e036bbb83b4052ae3599b4cd10042a
-  data.tar.gz: 90b851d491eb60c8357068344e08c0ac4a4a0150
+  metadata.gz: 91a21fb208a5322f64116f20e4b82e6108085b8d
+  data.tar.gz: 9a8b0eef2a85596da38cc1e51da31f699d5c6f94
 SHA512:
-  metadata.gz: 8e99c6314b1c3455c97c5c7f4baf348f604489439b50b2749e8fdedb4ab1f0f8e8530bb91841b7decdf10ee8dd107623a76d6d06b20dd258bea46982cb46b99f
-  data.tar.gz: de6b9297d956019d909a597b17a465d6281bb0aefc46e876d270925b52b00094bb948437d4ee1a1311229a810a96508ccfc3b95102ffe27ee50faac91fdd913f
+  metadata.gz: cc959379b26785e7f50b44461908985ef491eb94d6e765390145ca3416c130305c3ba7877837f9fbafefa9d149bd9816e72bf6d82c92dbc97c0cc9fe5bde58b3
+  data.tar.gz: faa8f17d79bf8579a6a5810e858f19e5adfff2635a213429e641ecbd1f8fe1e8373d27491f10182568b71859abe0349aa3a59c7ddb3c024e264fda38498b409b

data/.gitignore

@@ -0,0 +1 @@
+.ruby-version

data/.rspec

@@ -0,0 +1,5 @@
+--color
+--format documentation
+--profile
+--drb
+--require spec_helper

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+ruby '2.3.1'
+
+gem 'safe_yaml',  '~> 1.0'
+gem 'colorize',   '~> 0.7'
+gem 'xml-simple', '~> 1.1'
+
+gem 'webmock',    '~> 1.20'
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,44 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.4.0)
+    colorize (0.8.1)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.2.5)
+    hashdiff (0.3.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    safe_yaml (1.0.4)
+    webmock (1.24.6)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+    xml-simple (1.1.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  colorize (~> 0.7)
+  rspec
+  safe_yaml (~> 1.0)
+  webmock (~> 1.20)
+  xml-simple (~> 1.1)
+
+RUBY VERSION
+   ruby 2.3.1p112
+
+BUNDLED WITH
+   1.12.5

data/lib/bisu.rb

@@ -1,23 +1,30 @@
 require 'bisu/logger'
 require 'bisu/config'
-require 'bisu/knowledge_base'
-require 'bisu/translator'
+require 'bisu/google_sheet'
+require 'bisu/dictionary'
+require 'bisu/localizer'
 require 'bisu/version'
 require 'optparse'
 
 module Bisu
   extend self
 
-  def run(opts)
-    options = command_line_options(opts)
+  def run(options)
+    options = command_line_options(options)
 
     if config = Bisu::Config.parse("translatable.yml")
-      kbase = Bisu::GoogleDriveKB.new(config[:sheet_id], config[:keys_column])
-      translator = Bisu::Translator.new(kbase, config[:type])
+      google_sheet = Bisu::GoogleSheet.new(config[:sheet_id], config[:keys_column])
+      dictionary   = Bisu::Dictionary.new(google_sheet.to_hash)
+      localizer    = Bisu::Localizer.new(dictionary, config[:type])
 
       config[:in].each do |in_path|
         config[:out].each do |out|
-          localize(translator, out[:locale], out[:kb_language], options[:default_language], in_path, out[:path] || config[:out_path])
+          unless dictionary.has_language?(out[:kb_language])
+            Logger.error("Unknown language #{out[:kb_language]}")
+            return false
+          end
+
+          localize_file(localizer, out[:locale], out[:kb_language], options[:default_language], in_path, out[:path] || config[:out_path])
         end
       end
     end
@@ -28,11 +35,11 @@ module Bisu
   private
 
   def command_line_options(options)
-    options = {}
+    opts_hash = {}
 
     opts_parser = OptionParser.new do |opts|
       opts.on("-d LANGUAGE", "--default LANGUAGE", "Language to use when there is no available translation") do |language|
-        options[:default_language] = language
+        opts_hash[:default_language] = language
       end
 
       opts.on_tail("-h", "--help", "Show this message") do
@@ -45,12 +52,12 @@ module Bisu
         exit
       end
     end
+    opts_parser.parse!(options)
 
-    opts_parser.parse!(ARGV)
-    options
+    opts_hash
   end
 
-  def localize(translator, locale, language, default_language, in_path, out_path)
+  def localize_file(localizer, locale, language, default_language, in_path, out_path)
     in_name = File.basename(in_path)
     out_name = in_name.gsub(/\.translatable$/, "")
 
@@ -61,7 +68,32 @@ module Bisu
 
     out_path = out_path % { locale: locale, android_locale: locale.gsub("-", "-r"), out_name: out_name }
 
-    translator.translate(language, locale, in_path, out_path, default_language)
+    return false unless in_file  = open_file(in_path,  "r", true)
+    return false unless out_file = open_file(out_path, "w", false)
+
+    Logger.info("Translating #{in_path} to #{language} > #{out_path}...")
+
+    in_file.each_line do |line|
+      out_file.write(localizer.localize(line, language, locale, default_language))
+    end
+
+    out_file.flush
+    out_file.close
+    in_file.close
+
+    true
   end
 
+  def open_file(file_name, method, should_exist)
+    if !File.file?(File.expand_path(file_name))
+      if should_exist
+        Logger.error("File #{file_name} not found!")
+        return nil
+      else
+        FileUtils.mkdir_p(File.dirname(file_name))
+      end
+    end
+
+    File.open(File.expand_path(file_name), method)
+  end
 end

data/lib/bisu/dictionary.rb

@@ -0,0 +1,43 @@
+module Bisu
+  class Dictionary
+    def initialize(keys)
+      unless keys.is_a?(Hash)
+        raise ArgumentError.new("keys: expected Hash")
+      end
+
+      keys.each do |key,v|
+        unless v.is_a?(Hash)
+          raise ArgumentError.new("keys['#{key}']: expected Hash")
+        end
+
+        v.each do |lang,v|
+          unless v.is_a?(String) || v.nil?
+            raise ArgumentError.new("keys['#{key}']['#{lang}']: expected String")
+          end
+        end
+      end
+
+      @keys = keys
+    end
+
+    def has_language?(language)
+      languages.include?(language)
+    end
+
+    def localize(key, language)
+      if locals = @keys[key]
+        locals[language]
+      else
+        nil
+      end
+    end
+
+    private
+
+    def languages
+      @languages ||= begin
+        @keys.map { |_,v| v.keys }.flatten.uniq
+      end
+    end
+  end
+end

data/lib/bisu/google_sheet.rb

@@ -0,0 +1,63 @@
+require "net/https"
+require "xmlsimple"
+
+module Bisu
+  class GoogleSheet
+    def initialize(sheet_id, keys_column_title)
+      @sheet_id = sheet_id
+      @key_column = keys_column_title
+    end
+
+    def to_hash
+      raw = raw_data(@sheet_id)
+
+      Logger.info("Parsing Google Sheet...")
+
+      remove = ["id", "updated", "category", "title", "content", "link", @key_column]
+
+      kb = {}
+      raw["entry"].each do |entry|
+        hash = entry.select { |d| !remove.include?(d) }
+        hash = hash.each.map { |k, v| v.first == {} ? [k, nil] : [k, v.first] }
+
+        unless (key = entry[@key_column]) && key = key.first
+          raise "Cannot find key column '#{@key_column}'"
+        end
+
+        kb[key] = Hash[hash]
+      end
+
+      Logger.info("Google Sheet parsed successfully!")
+      Logger.info("Found #{kb.count} keys in #{kb.values.first.keys.count} languages.")
+
+      kb
+    end
+
+    private
+
+    def xml_data(uri, headers=nil)
+      uri = URI.parse(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      data = http.get(uri.path, headers)
+
+      unless data.code.to_i == 200
+        raise "Cannot access sheet at #{uri} - HTTP #{data.code}"
+      end
+
+      begin
+        XmlSimple.xml_in(data.body, 'KeyAttr' => 'name')
+      rescue
+        raise "Cannot parse. Expected XML at #{uri}"
+      end
+    end
+
+    def raw_data(sheet_id)
+      Logger.info("Downloading Google Sheet...")
+      sheet = xml_data("https://spreadsheets.google.com/feeds/worksheets/#{sheet_id}/public/full")
+      url   = sheet["entry"][0]["link"][0]["href"]
+      xml_data(url)
+    end
+  end
+end

data/lib/bisu/localizer.rb

@@ -0,0 +1,74 @@
+module Bisu
+  class Localizer
+    def initialize(dictionary, type)
+      @dict = dictionary
+      @type = type.downcase.to_sym
+
+      unless [:ios, :android, :ror].include?(@type)
+        Logger.error("Unknown type #{@type}")
+        raise "Unknown type #{@type}"
+      end
+    end
+
+    def localize(text, language, locale, default_language=nil)
+      t = text
+      t = t.gsub("$specialKLanguage$", language)
+      t = t.gsub("$specialKLocale$", locale)
+      t = t.gsub("$specialKComment1$", "This file was automatically generated based on a translation template.")
+      t = t.gsub("$specialKComment2$", "Remember to CHANGE THE TEMPLATE and not this file!")
+
+      to_localize(t).map do |l|
+        if localized = @dict.localize(l[:key], language) || @dict.localize(l[:key], default_language)
+          l[:params].each do |param, value|
+            if localized.match("%{#{param}}")
+              localized = localized.gsub("%{#{param}}", value)
+            else
+              Logger.error("Parameter #{param} not found in translation for #{l[:key]} in #{language}")
+            end
+          end
+          t = t.gsub(l[:match], process(localized))
+        end
+      end
+
+      t.scan(/\$(k[^\$\{]+)(?:\{(.+)\})?\$/) { |match| Logger.warn("Could not find translation for #{match[0]} in #{language}") }
+      unless @type.eql?(:ror)
+        t.scan(/%{[^}]+}/) { |match| Logger.error("Could not find translation param for #{match} in #{language}") }
+      end
+
+      t
+    end
+
+    private
+
+    def to_localize(text)
+      all_matches = text.to_enum(:scan, /\$(k[^\$\{]+)(?:\{(.+)\})?\$/).map { Regexp.last_match }
+      all_matches.map do |match|
+        params = if match[2]
+          params = match[2].split(",").map(&:strip).map do |param|
+            key, value = param.split(":", 2).map(&:strip)
+            [key.to_sym, value]
+          end
+          Hash[params]
+        end
+
+        { match:  match[0],
+          key:    match[1],
+          params: params || {} }
+      end
+    end
+
+    def process(text)
+      if @type.eql?(:android)
+        text = text.gsub(/[']/, "\\\\\\\\'")
+        text = text.gsub("...", "…")
+        text = text.gsub("& ", "& ")
+        text = text.gsub("@", "\\\\@")
+
+      elsif @type.eql?(:ios)
+        text = text.gsub(/\"/, "\\\\\"")
+      end
+
+      text
+    end
+  end
+end

data/lib/bisu/version.rb

@@ -1,4 +1,4 @@
 module Bisu
-  VERSION = '1.2.3'
-  VERSION_UPDATED_AT = '2016-10-14'
+  VERSION = '1.2.4'
+  VERSION_UPDATED_AT = '2016-10-23'
 end

data/spec/bisu/config_spec.rb

@@ -0,0 +1,35 @@
+describe Bisu::Config do
+  subject { Bisu::Config.parse(file_path) }
+
+  context "given a yml file" do
+    let(:file_path) { "spec/fixtures/sample_translatable.yml" }
+
+    it "should parse the yml with deep key symbolization" do
+      expect(subject).to eq({
+        type:        "BisuOS",
+        sheet_id:    "abc1234567890",
+        keys_column: "key_name",
+        in:          [
+          "path/to/file/to/1.ext.translatable",
+          "path/to/file/to/2.ext.translatable"
+        ],
+        out_path:    "path/to/final-%{locale}/%{out_name}",
+        out:         [
+          { locale: "en",    kb_language: "english", path: "path/to/default/%{out_name}" },
+          { locale: "pt",    kb_language: "portuguese" },
+          { locale: "pt-PT", kb_language: "portuguese" }
+        ]
+      })
+    end
+  end
+
+  context "given an inexistent file" do
+    let(:file_path) { "does_not_exist" }
+    it { should be nil }
+  end
+
+  context "given no file path" do
+    let(:file_path) { nil }
+    it { should be nil }
+  end
+end

data/spec/bisu/dictionary_spec.rb

@@ -0,0 +1,69 @@
+describe Bisu::Dictionary do
+  subject(:dict) { Bisu::Dictionary.new(keys) }
+
+  describe ".initialize" do
+    let(:keys) { { "kNo1" => { "lang" => "text" } } }
+    it { expect { subject }.not_to raise_error }
+
+    context "when created with invalid type parameters" do
+      let(:keys) { "cenas" }
+      it { expect { subject }.to raise_error /expected Hash$/ }
+    end
+
+    context "when created with an invalid json schema" do
+      let(:keys) { { "kNo1" => "text" } }
+      it { expect { subject }.to raise_error /kNo1.+expected Hash/ }
+    end
+
+    context "when created with an invalid json schema" do
+      let(:keys) { { "kNo1" => { "a-lang" => { "wtvr" => "text" } } } }
+      it { expect { subject }.to raise_error /kNo1.+a-lang.+expected String/ }
+    end
+
+    context "when given empty translations" do
+      let(:keys) { { "kNo1" => { "lang" => nil } } }
+      it { expect { subject }.not_to raise_error }
+    end
+  end
+
+  describe "#has_language?" do
+    let(:keys) { {
+      "kNo1" => { "lang1" => "no1-lang1", "lang2" => "no1-lang2" },
+      "kNo2" => { "lang2" => "no2-lang2", "lang3" => "no2-lang3" }
+    } }
+
+    it "returns true if that language is translated" do
+      expect(dict.has_language?("lang2")).to be true
+    end
+
+    it "returns true if that language is only partially translated" do
+      expect(dict.has_language?("lang3")).to be true
+    end
+
+    it "returns false if that language does not exist in any key" do
+      expect(dict.has_language?("lang-no-available")).to be false
+    end
+  end
+
+  describe "#localize" do
+    let(:keys) { {
+      "kCray" => {
+        "english" => "You are crazy!",
+        "portuguese" => "Estás maluco!",
+        "kriolo" => "Bo sta crazy!"
+      }
+    } }
+
+    it "localizes a key" do
+      expect(dict.localize("kCray", "kriolo")).to eq "Bo sta crazy!"
+    end
+
+    it "returns nil when the key does not exist" do
+      expect(dict.localize("kDoesntExist", "kriolo")).to be nil
+    end
+
+    it "returns nil when language is not available" do
+      expect(dict.localize("kCray", "finish")).to be nil
+    end
+  end
+end