n42translation 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce8725b1932a987f51bba7099ce82a312bb9b821
+  data.tar.gz: 51a8089a033c2df52d87572f35562d87cfb9add8
+SHA512:
+  metadata.gz: bba10b71bb89113f79ec7c4b247083c758fa73cb7ae50a828a19533ec76c908d8afce7ffd11490029508dd279668ecc28fe3c9c02d3a2a40564a13aff85a1ea4
+  data.tar.gz: 67fe97b54058148d71d9226808de9c9239ba4ff8816c398d4c246cf46d3186bdd29afa6b2308c63f7fbcd58b5876ffd1f028e04e2edfdf4ca0d4bc7f77856e42

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+locales/Android
+locales/csv
+locales/iOS
+locales/Rails
+locales/builds

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+
+# Specify your gem's dependencies in gem_name.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    n42translation (0.0.9)
+      activesupport
+      builder
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    i18n (0.7.0)
+    json (1.8.2)
+    minitest (5.5.1)
+    rubyzip (1.1.7)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    write_xlsx (0.83.0)
+      rubyzip (>= 1.0.0)
+      zip-zip
+    zip-zip (0.3)
+      rubyzip (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  n42translation!
+  write_xlsx

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Number42
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/Readme.md

@@ -0,0 +1,31 @@
+# n42translation Tool
+Creates locale files for iOS, Android and Rails from common source files.
+
+## Source Files
+### Config File
+
+* n42translation-config.yml defines the default outputpaths for Android, iOS and Rails
+
+### Language Files
+
+* <fileprefix>.<lang>.yml (e.g. horsch.en.yml) contains keys for all platforms
+* <fileprefix>.<lang>.<target>.yml (e.g. horsch.en.android.yml) contains keys for only this target platform
+
+## Examples
+
+* bundle exec n42translation build android horsch: builds the locales for android from the sources to the default folder given in the config file
+* bundle exec n42translation build android horsch myAndroid: builds the locales for android from the sources to the myAndroid folder
+* bundle exec n42translation build all horsch: build ios, android and rails to the default folders
+* bundle exec n42translation add all horsch "path.to.my_message" "my new message": adds the key path.to.my_message with value "my new message" to the horsch.<lang>.yml files
+* bundle exec n42translation add all ios "path.to.my_message" "my new message": adds the key path.to.my_message with value "my new message" to the horsch.<lang>.ios.yml files
+
+
+### HOW TO INITILAIZE A PROJECT
+
+* you first have to run the initilizer script:
+bundle exec n42translation init <project_name> <target> <languages>
+
+* so lets say if you wanted to initialize a project with name stack:
+bundle exec n42translation init stacks all "en,de"
+
+* this creates a config file, and the necessary target-yaml files for the languages en and de

data/bin/n42translation

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'n42translation/cli'
+N42translation::CLI.start

data/lib/n42translation.rb

@@ -0,0 +1,3 @@
+module N42translation
+  # Your code goes here...
+end

data/lib/n42translation/cli.rb

@@ -0,0 +1,266 @@
+require 'thor'
+require 'yaml'
+require 'active_support'
+require 'n42translation/xml'
+require 'n42translation/strings'
+require 'n42translation/csv_convert'
+require 'n42translation/xlsx'
+require 'n42translation/config'
+require 'fileutils'
+require 'csv'
+
+module N42translation
+  class CLI < Thor
+
+    desc "init <project-name> <target> <languages>", "init"
+    def init(project_name, target = nil, languages = nil)
+      config = load_config_file(project_name)
+
+      build_path = config["build_path"]
+      source_path = config["source_path"]
+
+      project_name = config["project_name"] if project_name.nil?
+
+      targets = []
+      targets = [target] if target != nil && target != ""
+      targets = config["targets"]["all"].split(',').map(&:lstrip).map(&:rstrip) if target === "all"
+      targets = config["targets"]["mobile"].split(',').map(&:lstrip).map(&:rstrip) if target === "mobile"
+      targets << "" # we want a platform named "all", to build from 'platform' + 'all' files
+
+      raise Thor::Error, "no build path found" if build_path.nil?
+      raise Thor::Error, "no locale path found" if source_path.nil?
+      raise Thor::Error, "no project name was specified" if project_name.nil?
+      raise Thor::Error, "no targets specified" if targets.nil?
+
+      # write config File
+      puts config.to_yaml
+      File.open("config.#{project_name}.yml", 'w'){|file| file.write config.to_yaml} unless File.exists?("config.#{project_name}.yml")
+
+      languages = config["languages"] if languages.nil?
+      langs = languages.split(',').map(&:lstrip).map(&:rstrip)
+      langs = (langs + get_languages(project_name)).uniq
+
+      targets.each do |_target|
+        build(_target, project_name, build_path) unless _target == "all"
+
+        langs.each do |lang|
+          filename = File.join(source_path, "#{project_name}.#{lang}.yml") if _target ===""
+          filename = File.join(source_path, "#{project_name}.#{lang}.#{_target}.yml") unless _target === ""
+          File.open(filename, 'w') { |file| file.write("---") } unless File.exists?(filename)
+        end
+      end
+    end
+
+    desc "build <target> <project_name> <outputfile_path> <default-language>", "builds the files for the target (all, ios, android, rails) for the project_name (e.g. horsch) to the outputfile_path (if given, they are taken from the config file otherwise)"
+    def build(target, project_name, outputfile_path=nil, default_language="en")
+      config = load_config_file(project_name)
+
+      outputfile_path = config["build_path"] if outputfile_path.nil?
+      raise Thor::Error, "no output path specified" if outputfile_path.nil?
+
+      source_path = config["source_path"]
+      raise Thor::Error, "no source path specified" if source_path.nil?
+
+      path_name = config["target_build_path_names"][target.to_s].to_s
+      target_build_path = File.join(outputfile_path, path_name)
+
+      case target.to_sym
+      when :all
+        self.build(:android, project_name, outputfile_path)
+        self.build(:ios, project_name, outputfile_path)
+        self.build(:rails, project_name, outputfile_path)
+        self.build(:csv, project_name, outputfile_path)
+        self.build(:xlsx, project_name, outputfile_path)
+      when :android
+        raise Thor::Error, "no build path specified for your target: #{target}" if target_build_path.nil?
+        build_platform(source_path, project_name, target_build_path, target, :xml)
+      when :ios
+        raise Thor::Error, "no build path specified for your target: #{target}" if target_build_path.nil?
+        build_platform(source_path, project_name, target_build_path, target, :strings)
+      when :rails
+        raise Thor::Error, "no build path specified for your target: #{target}" if target_build_path.nil?
+        build_platform(source_path, project_name, target_build_path, target, :yml)
+      when :csv
+        raise Thor::Error, "no build path specified for your target: #{target}" if target_build_path.nil?
+        build_csv(source_path, project_name, target_build_path, [:all, :ios, :android, :rails], default_language)
+      when :xlsx
+        raise Thor::Error, "no build path specified for your target: #{target}" if target_build_path.nil?
+        build_xlsx(source_path, project_name, target_build_path, [:all, :ios, :android, :rails], default_language)
+      when "".to_sym
+        # ignore the “” case
+      else
+        raise Thor::Error, "unknown target: #{target}"
+      end
+    end
+
+    desc "add <target> <project_name> <key> <value> <language>", "creates or updates the specified <value> for the <key> in the <target> in the project <project_name> for the specified <language>(default: 'en') will add a 'TODO: <value>(<language>)' to all other languages"
+    def add(target, project_name, key, value, language = "en")
+      # puts "#{target}, #{project_name}, #{key}, #{value}, #{language}"
+      insert_string(target, project_name, key, value, language, :override)
+    end
+
+    desc "update <target> <project_name> <key> <value> <language>", "updates or creates the specified <value> for the <key> in the <target> for the project <project_name>. Optional is language(default: 'en') will add to specific <language>"
+    def update(target, project_name, key, new_value, language="en")
+      insert_string(target, project_name, key, new_value, language, :update)
+    end
+
+
+
+    private
+    ## Helper
+
+    # inserts string into languages
+    def insert_string(target, project_name, key, value, language = "en", mode)
+      config = load_config_file(project_name)
+      source_path = config["source_path"]
+
+      get_languages(project_name).each do |lang|
+        if lang === language
+          val = value
+          insert_string_into_language(key, value, lang, source_path, project_name, target)
+        else
+          next if mode === :update
+          val = "TODO: #{value}(#{language.upcase})"
+          insert_string_into_language(key, val, lang, source_path, project_name, target) if mode === :override
+        end
+      end
+    end
+
+    def insert_string_into_language(key, value, language, source_path, project_name, target)
+      # hash is a string here
+      hash = value
+
+      key.split(".").reverse.each do |keypart|
+        # hash is a hash after calling this the first time
+        hash = {keypart => hash}
+      end
+
+      fileContent = yaml_for_platform_and_lang(source_path, project_name, target.to_sym, language).deep_merge(hash).to_yaml
+      save_with_target(fileContent, language, project_name, target)
+    end
+
+    def load_config_file(project_name = "default")
+      default_yml = N42translation::Config.default_yml
+      project_path = "./config.#{project_name}.yml"
+      project_yml = load_yaml(project_path)
+
+      return default_yml if ( project_yml.nil? || project_yml == false || project_yml.empty?)
+      default_yml.deep_merge(project_yml)
+    end
+
+    # returns the language part of filenames as array following <project_name>.<lang>.yml
+    def get_languages(project_name)
+      config = load_config_file(project_name)
+
+      source_path = config["source_path"]
+      raise Thor::Error, "no locale path found" if source_path.nil?
+
+      langs = Dir.glob("#{source_path}/#{project_name}.*.yml").map{|f| File.basename(f,".yml").split(".")[1]}
+      langs.uniq
+    end
+
+    def save_with_filename(content, lang, project_name, outputfile_path, method)
+      filename = ""
+      case method
+      when :xml
+        filename = "#{outputfile_path}/values-#{lang}/strings-generated.xml"
+      when :strings
+        filename = "#{outputfile_path}/#{lang}.lproj/Localizable.strings"
+      when :yml
+        filename = "#{outputfile_path}/#{project_name}.#{lang}.yml"
+      end
+
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, 'w') { |file| file.write(content) }
+    end
+
+    def save_with_target(content, lang, project_name, target)
+      filename = "#{project_name}.#{lang}.yml"  if target.eql? "all"
+      filename = "#{project_name}.#{lang}.#{target}.yml" unless target.eql? "all"
+
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, 'w') { |file| file.write(content) }
+    end
+
+    def load_yaml(file_path)
+      if File.exist?(file_path)
+        YAML.load_file(file_path) || {}
+      else
+        return YAML.load("---")
+      end
+    end
+
+    def load_merged_yaml_for_platform(source_path, project_name, language, platform)
+      yaml = load_yaml(File.join(source_path,"#{project_name}.#{language}.yml"))
+      target_yaml = load_yaml(File.join(source_path,"#{project_name}.#{language}.#{platform.to_s}.yml"))
+      return yaml.deep_merge(target_yaml) if !target_yaml.nil? || target_yaml === false
+      yaml
+    end
+
+    ## Builder
+    def build_platform(source_path, project_name, outputfile_path, platform, method)
+      get_languages(project_name).each do |lang|
+        yaml = load_merged_yaml_for_platform(source_path, project_name, lang, platform)
+        fileContent = ""
+        fileContent = N42translation::XML.createXML(join_hash_keys(yaml, "_")).target! if method == :xml
+        fileContent = N42translation::Strings.createStrings(join_hash_keys(yaml, ".")).join("\n") if method == :strings
+        fileContent = yaml.to_yaml if method == :yml
+        save_with_filename(fileContent, lang, project_name, outputfile_path, method)
+      end
+    end
+
+    def build_csv(source_path, project_name, outputfile_path, platforms, default_language)
+      languages = get_languages(project_name)
+      language_yamls = {}
+      languages.each do |language|
+        language_yamls["#{language}"] = platforms.map {|platform| yaml_for_platform_and_lang(source_path, project_name, platform, language) }.reduce({}, :merge)
+      end
+
+      csv_data = N42translation::CSVConvert.createCSV(language_yamls.values.map{|yml| join_hash_keys(yml,'.')}, languages, join_hash_keys(language_yamls[default_language],'.'), default_language)
+
+      filename = File.join(outputfile_path,'csv',"#{project_name}.csv")
+      FileUtils.mkpath(File.dirname(filename))
+      File.open(filename, "w") {|f| f.write(csv_data.inject([]) { |csv, row|  csv << CSV.generate_line(row) }.join(""))}
+    end
+
+    def build_xlsx(source_path, project_name, outputfile_path, platforms, default_language)
+      languages = get_languages(project_name)
+      language_yamls = {}
+      languages.each do |language|
+        language_yamls["#{language}"] = platforms.map {|platform| yaml_for_platform_and_lang(source_path, project_name, platform, language) }.reduce({}, :merge)
+      end
+
+      csv_data = N42translation::CSVConvert.createCSV(language_yamls.values.map{|yml| join_hash_keys(yml,'.')}, languages, join_hash_keys(language_yamls[default_language],'.'), default_language)
+
+      filename = File.join(outputfile_path,'xlsx',"#{project_name}.xlsx")
+      FileUtils.mkpath(File.dirname(filename))
+
+      N42translation::XLSX.create(csv_data, filename, project_name)
+    end
+
+
+    def yaml_for_platform_and_lang(source_path, project_name, platform, language)
+      if platform == :all
+        load_yaml(File.join(source_path,"#{project_name}.#{language}.yml")).to_h
+      else
+        load_yaml(File.join(source_path,"#{project_name}.#{language}.#{platform.to_s}.yml")).to_h
+      end
+    end
+
+
+    ## Hash Helper
+
+    # flatten the hash, ["a" => ["b" => "c"]] becomes [["a", "b"]=>"c"]
+    def flat_hash(h,f=[],g={})
+      return g.update({ f=>h }) unless h.is_a? Hash
+        h.each { |k,r| flat_hash(r,f+[k],g) }
+        g
+    end
+
+    # flatten and jon the hash keys, [["a", "b"]=>"c"] becomes ["a.b"=>"c"]
+    def join_hash_keys(hash, joiner)
+      Hash[flat_hash(hash).map {|k, v| [k.join(joiner), v] }]
+    end
+
+  end
+end

data/lib/n42translation/config.rb

@@ -0,0 +1,23 @@
+require 'yaml'
+
+module N42translation
+  class Config
+    def self.default_yml
+      YAML.load('
+        build_path: ./builds
+        source_path: ./
+        project_name: n42translation_project
+        languages: de,en
+        targets:
+          all: ios,android,rails,csv,xlsx
+          mobile: ios,android
+        target_build_path_names:
+          android: Android
+          ios: iOS
+          rails: Rails
+          csv: CSV
+          xlsx: EXCEL
+      ')
+    end
+  end
+end

data/lib/n42translation/csv_convert.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+
+module N42translation
+  class CSVConvert
+    def self.createCSV(ymls, langs, default_yml, default_language)
+
+      keys = ymls.map{|yml| yml.keys }.flatten.uniq
+
+      rows = []
+      rows << ["key",langs].flatten
+
+      keys.each do |key|
+        rows << [key, get_values_from_key(ymls, key, default_yml, default_language)].flatten
+      end
+
+      rows
+    end
+
+    private
+    def self.get_values_from_key(ymls, key, default_yml, default_language)
+      ymls.map do |yml|
+        val = yml[key.to_s]
+        if yml[key.to_s].nil?
+          default_val = default_yml[key.to_s]
+          if default_val.nil?
+            "TODO: "
+          else
+            "TODO: #{default_val}(#{default_language.to_s.upcase})"
+          end
+        else
+          val
+        end
+      end
+    end
+  end
+end