ios_polyglot_cli 2.0.1

data/lib/ios_polyglot_cli/commands/setup.rb

@@ -0,0 +1,80 @@
+require 'commander/blank'
+require 'commander/command'
+
+module PolyglotIos
+  module Command
+    class Setup
+      include Helper::Terminal
+      include Helper::General
+
+      def self.init(options = Commander::Command::Options.new)
+        new(options).call
+      end
+    
+      def initialize(options = Commander::Command::Options.new)
+        @options = options
+      end
+
+      def call
+        project_id = project_id_prompt
+        language = language_prompt
+        translations_path = translations_path_prompt
+        sources_path = sources_path_prompt
+        project = {
+          id: project_id,
+          path: translations_path,
+          sourceFilesPath: sources_path
+        }
+        config = {
+          language: language,
+          projects: [project]
+        }
+        PolyglotIos::IO::Config.write(config)
+        success
+      end
+
+      private
+
+      # Project ID
+
+      def project_id_prompt
+        prompt.select('Choose a project: ', filtered_projects)
+      end
+
+      def projects
+        prompt.say('Getting projects...')
+        PolyglotIos::Resource::Project.token(token).depaginate.each_with_object({}) do |r, hash|
+          hash[r.name] = r.id
+        end
+      end
+    
+      def filtered_projects
+        projects.select { |key, _id| key[/^(.*?(#{option_query})[^$]*)$/i] }.sort_by { |p| p[0].downcase }.to_h
+      end
+    
+      def option_query
+        @option_query ||= @options.__hash__.fetch(:query, '')
+      end
+
+      # Language
+
+      def language_prompt
+        languages = {'Swift' => 'swift', 'Objective-C' => 'objc'}
+        prompt.select('Choose a language: ', languages)
+      end
+
+      # Translations path
+
+      def translations_path_prompt
+        prompt.ask('Where would you like to store translation files (.strings)?', default: './Resources/Translations/')
+      end
+
+      # Sources path
+
+      def sources_path_prompt
+        prompt.ask('Where would you like to store source files?', default: './Common/Translations/')
+      end
+
+    end
+  end
+end

data/lib/ios_polyglot_cli/error_handler.rb

@@ -0,0 +1,28 @@
+module PolyglotIos
+  class ErrorHandler
+    extend Helper::Terminal
+
+    class << self
+      def rescuable
+        yield
+      rescue => e
+        handle(e)
+      end
+
+      def handle(e)
+        prompt.error(
+          case e
+          when JsonApiClient::Errors::NotAuthorized
+            "You are not authorized. Please call `polyglot login` and provide correct credentials."
+          when JsonApiClient::Errors::AccessDenied
+            "You don't have the permission to access requested project."
+          when Errno::ENOENT
+            "We could not find a file that we need:\n\n#{e.message}"
+          else
+            "An error happened. This might help:\n\n#{e.message}"
+          end
+        )
+      end
+    end
+  end
+end

data/lib/ios_polyglot_cli/helpers/depaginate.rb

@@ -0,0 +1,18 @@
+module PolyglotIos
+  module Helper
+    module Depaginate
+      PER_PAGE = 100
+
+      def depaginate_query(query)
+        depaginated_array = []
+        page = query.page(1).per(PER_PAGE).all
+        until page.nil?
+          depaginated_array += page
+          page = page.pages.next
+        end
+        depaginated_array
+      end
+      
+    end
+  end
+end

data/lib/ios_polyglot_cli/helpers/general.rb

@@ -0,0 +1,79 @@
+module PolyglotIos
+  module Helper
+    module General
+      ESCAPE_KEYWORDS = ["associatedtype", "class", "deinit", "enum", "extension", "fileprivate", "func", 
+                         "import", "init", "inout", "internal", "let", "operator", "private", "protocol", 
+                         "public", "static", "struct", "subscript", "typealias", "var", "break", "case", 
+                         "continue", "default", "defer", "do", "else", "fallthrough", "for", "guard", "if", 
+                         "in", "repeat", "return", "switch", "where", "while", "as", "Any", "catch", "false", 
+                         "is", "nil", "rethrows", "super", "self", "Self", "throw", "throws", "true", "try", "_"]
+      def token
+        @token ||= PolyglotIos::IO::Token.read
+        if @token.to_s.empty?
+          PolyglotIos::Command::Login.init
+          @token = PolyglotIos::IO::Token.read
+        end
+        @token
+      end
+  
+      def config
+        @config ||= PolyglotIos::IO::Config.read.with_indifferent_access
+      end
+      
+      def project_configs
+        @project_configs ||= config[:projects]
+      end
+
+      def programming_language
+        @programming_language ||= config[:language]
+      end
+
+      def use_old_naming
+        @useOldNaming ||= config[:useOldNaming]
+      end
+
+      def indent(level = 0, initial = "")
+        (1..level)
+          .to_a.reduce("") { |result, value| result + "    " }
+          .concat(initial)
+      end
+
+      def clean_enum_name(name)
+        clean_name = name
+          .split(/[^0-9a-zA-Z]/)
+          .reject { |c| c.empty? }
+          .map { |value| value.capitalize }
+          .join
+
+        escape_with_underscore_if_needed(clean_name)
+      end
+
+      def clean_case_name(name)
+        clean_variable_name(name)
+      end
+
+      def clean_variable_name(name)
+        clean_name = name
+          .split(/[^0-9a-zA-Z]/)
+          .reject { |c| c.empty? }
+          .each_with_index
+          .map { |value, index| index == 0 ? value.downcase : value.capitalize }
+          .join
+
+        escaped_underscore = escape_with_underscore_if_needed(clean_name)
+        escape_keyword_if_needed(escaped_underscore)
+      end
+      
+      def escape_with_underscore_if_needed(name)
+        return name if name.match(/^[A-Za-z_]/)
+        "_" + name
+      end
+
+      def escape_keyword_if_needed(name)
+        return name if !ESCAPE_KEYWORDS.include? name
+        "`#{name}`"
+      end
+
+    end
+  end
+end

data/lib/ios_polyglot_cli/helpers/terminal.rb

@@ -0,0 +1,17 @@
+require 'tty-prompt'
+
+module PolyglotIos
+  module Helper
+    module Terminal
+
+      def success(message = 'Success!')
+        prompt.ok(message)
+      end
+
+      def prompt
+        @prompt ||= TTY::Prompt.new(interrupt: :exit)
+      end
+
+    end
+  end
+end

data/lib/ios_polyglot_cli/io/config.rb

@@ -0,0 +1,20 @@
+module PolyglotIos
+  module IO
+    class Config
+
+      CONFIG_FILE_PATH = "#{Dir.pwd}/polyglot.yml".freeze
+
+      class << self
+        def write(data)
+          File.open(CONFIG_FILE_PATH, 'w') { |file| YAML.dump(data, file) }
+        end
+
+        def read
+          YAML.load_file(CONFIG_FILE_PATH)
+        end
+      end
+      
+    end
+  end
+end
+  

data/lib/ios_polyglot_cli/io/token.rb

@@ -0,0 +1,25 @@
+module PolyglotIos
+  module IO
+    class Token
+
+      KEYCHAIN_SERVICE = 'polyglot'.freeze
+      KEYCHAIN_TOKEN_KEY = 'polyglot_token'.freeze
+      
+      class << self
+        def write(token)
+          keychain[KEYCHAIN_SERVICE, KEYCHAIN_TOKEN_KEY] = token
+        end
+    
+        def read
+          keychain[KEYCHAIN_SERVICE, KEYCHAIN_TOKEN_KEY]
+        end
+
+        def keychain
+          @keychain ||= OSXKeychain.new
+        end
+
+      end
+    end
+  end
+end
+  

data/lib/ios_polyglot_cli/serializers/languages/languages_serializer.rb

@@ -0,0 +1,27 @@
+module PolyglotIos
+  module Serializer
+    module Language
+      class Base
+        include ERB::Util
+        attr_accessor :languages
+
+        def initialize(languages)
+          @languages = languages
+        end
+        
+        def render()
+          ERB.new(template, nil, '-').result(binding)
+        end
+
+        def template()
+          fail NotImplementedError, 'Abstract Method'
+        end
+
+        def save(path)
+          fail NotImplementedError, 'Abstract Method'
+        end
+
+      end
+    end
+  end
+end

data/lib/ios_polyglot_cli/serializers/languages/languages_serializer_objc.rb

@@ -0,0 +1,90 @@
+require_relative 'languages_serializer'
+
+module PolyglotIos
+  module Serializer
+    module Language
+      class ObjC < Base
+        
+        def render()
+          h_file = ERB.new(h_template, nil, '-').result(binding)
+          m_file = ERB.new(m_template, nil, '-').result(binding)
+          return h_file, m_file
+        end
+        
+        def save(sources_path)
+          FileUtils.mkdir_p sources_path unless File.exist? sources_path
+          h_file, m_file = render()
+          File.write(File.join(sources_path, "Language.h"), h_file)
+          File.write(File.join(sources_path, "Language.m"), m_file)
+        end
+
+        def h_template()
+<<-H_TEMPLATE
+#import <Foundation/Foundation.h>
+
+@interface Language : NSObject
+
+@property (nonatomic, strong, readonly) NSString *name;
+@property (nonatomic, strong, readonly) NSString *localName;
+@property (nonatomic, strong, readonly) NSString *locale;
+@property (nonatomic, strong, readonly) NSString *languageCode;
+
+@property (readonly, class) NSArray<Language *> *allLanguages;
+<% @languages.each do |language| -%>
+@property (readonly, class) Language *<%= language.clean_name %>;
+<% end -%>
+
+@end
+H_TEMPLATE
+        end
+
+        def m_template()
+<<-M_TEMPLATE
+#import "Language.h"
+
+@interface Language()
+
+@property (nonatomic, strong) NSString *name;
+@property (nonatomic, strong) NSString *localName;
+@property (nonatomic, strong) NSString *locale;
+@property (nonatomic, strong) NSString *languageCode;
+
+@end
+
+@implementation Language
+
+- (instancetype)initWithName:(NSString *)name localName:(NSString *)localName locale:(NSString *)locale languageCode:(NSString *)languageCode
+{
+    if (self = [super init]) {
+        _name = name;
+        _localName = localName;
+        _locale = locale;
+        _languageCode = languageCode;
+    }
+    return self;
+}
+
+<% @languages.each do |language| -%>
++ (Language *)<%= language.clean_name %>
+{
+    return [[Language alloc] initWithName:@"<%= language.name %>" localName:@"<%= language.local_name %>" locale:@"<%= language.locale %>" languageCode:@"<%= language.code %>"];
+}
+
+<% end -%>
++ (NSArray<Language *> *)allLanguages 
+{
+    return @[
+<% @languages.each_with_index do |language, i| -%>
+        Language.<%= language.clean_name %><%= i == (@languages.size - 1) ? "" : "," %>
+<% end -%>
+    ];
+}
+
+@end
+M_TEMPLATE
+        end
+
+      end
+    end
+  end
+end

data/lib/ios_polyglot_cli/serializers/languages/languages_serializer_swift.rb

@@ -0,0 +1,41 @@
+require_relative 'languages_serializer'
+
+module PolyglotIos
+  module Serializer
+    module Language
+      class Swift < Base
+
+        def save(sources_path)
+          FileUtils.mkdir_p sources_path unless File.exist? sources_path
+          output_path = File.join(sources_path, "Language.swift")
+          File.write(output_path, render)
+        end
+
+        def template()
+<<-TEMPLATE
+import Foundation
+
+public struct Language {
+
+    public let name: String
+    public let localName: String
+    public let locale: String
+    public let languageCode: String
+
+<% @languages.each do |language| -%>
+    public static let <%= language.clean_name %> = Language(name: "<%= language.name %>", localName: "<%= language.local_name %>", locale: "<%= language.locale %>", languageCode: "<%= language.code %>")
+<% end -%>
+
+    public static let all = [
+<% @languages.each_with_index do |language, i| -%>
+        Language.<%= language.clean_name %><%= i == (@languages.size - 1) ? "" : "," %>
+<% end -%>
+    ]
+
+}
+TEMPLATE
+        end
+      end
+    end
+  end
+end

data/lib/ios_polyglot_cli/serializers/sources/sources_serializer_swift.rb

@@ -0,0 +1,63 @@
+require_relative 'swift_helpers/translation_case'
+require_relative 'swift_helpers/translation_enum'
+
+module PolyglotIos
+  module Serializer
+    module Source
+      class Swift
+        include ERB::Util
+        
+        def initialize(translation_keys)
+          @translation_keys = translation_keys
+        end
+        
+        def render()
+          @root_enum = build_translations()
+          ERB.new(template, nil, '-').result(binding)
+        end
+
+        def template()
+<<-TEMPLATE
+import Foundation
+
+<%= @root_enum.serialized() %>
+public protocol StringsProtocol: RawRepresentable {
+    var localized: String { get }
+    func localized(with args: CVarArg...) -> String
+}
+
+public extension StringsProtocol where RawValue == String {
+    var localized: String {
+        return self.rawValue.localized
+    }
+
+    func localized(with args: CVarArg...) -> String {
+        return String(format: self.rawValue.localized, arguments: args)
+    }
+}
+TEMPLATE
+        end
+
+        def build_translations()
+          root_enum = TranslationEnum.new("Strings")
+          
+          @translation_keys.each do |translation_key|
+            key_name = translation_key.name
+            next if key_name.nil?
+            components = key_name.split(".")
+            root_enum.insert(components, key_name)
+          end
+
+          return root_enum
+        end
+
+        def save(sources_path)
+          FileUtils.mkdir_p sources_path unless File.exist? sources_path
+          output_path = File.join(sources_path, "Strings.swift")
+          File.write(output_path, render)
+        end
+
+      end
+    end
+  end
+end

data/lib/ios_polyglot_cli/serializers/sources/swift_helpers/translation_case.rb

@@ -0,0 +1,23 @@
+module PolyglotIos
+  module Serializer
+    module Source
+      class TranslationCase
+        include Helper::General
+
+        attr_accessor :name
+        attr_accessor :value
+
+        def initialize(name, value)
+          @name = name
+          @value = value
+        end
+
+        def serialized()
+          clean_name = clean_case_name(name)
+          "case #{clean_name} = \"#{value}\""
+        end
+        
+      end
+    end
+  end
+end

data/lib/ios_polyglot_cli/serializers/sources/swift_helpers/translation_enum.rb

@@ -0,0 +1,84 @@
+require_relative 'translation_case'
+
+module PolyglotIos
+  module Serializer
+    module Source
+      class TranslationEnum
+        include Helper::General
+        attr_accessor :name
+        attr_accessor :translations
+        attr_accessor :child_enums
+
+        def initialize(name)
+          @name = name
+          @translations = []
+          @child_enums = []
+        end
+
+        def insert(components, key_name)
+          if components.count > 1
+            insert_to_nested_enum(components, key_name)
+          elsif components.count == 1
+            translation_case = TranslationCase.new(components.first, key_name)
+            translations.push(translation_case)
+          end
+        end
+
+        def serialized(indent_level = 0)
+          output = indent(indent_level)
+          clean_name = clean_enum_name(name)
+
+          if translations.count == 0
+            # enum without any case statement cannot be RawRepresentable
+            output.concat("public enum #{clean_name} {\n")
+          else
+            output.concat("public enum #{clean_name}: String, StringsProtocol {\n")
+          end
+
+          translations
+            .sort_by { |translation| translation.name.downcase }
+            .each do |translation|
+              output
+                .concat(indent(indent_level + 1, translation.serialized()))
+                .concat("\n")
+            end
+          
+          if translations.count > 0 && child_enums.count > 0
+            output.concat("\n")
+          end
+            
+          serialized_enums = child_enums
+            .sort_by { |child_enum| child_enum.name.downcase }
+            .map { |child_enum| child_enum.serialized(indent_level + 1) }
+            .join("\n")
+          output.concat(serialized_enums)
+
+          output.concat(indent(indent_level, "}\n"))
+          return output
+        end
+
+        private
+
+        def insert_to_nested_enum(components, key_name)
+          _components = components.clone
+
+          enum_name = _components.shift
+          nested_enum = nested_enum_with_name(enum_name)
+
+          if !nested_enum.nil?
+            nested_enum.insert(_components, key_name)
+          else
+            child = TranslationEnum.new(enum_name)
+            child.insert(_components, key_name)
+            @child_enums.push(child)
+          end
+        end
+
+        def nested_enum_with_name(name)
+          child_enums.find { |enum| enum.name == name }
+        end
+        
+      end
+    end
+  end
+end

data/lib/ios_polyglot_cli/serializers/translations/translations_serializer.rb

@@ -0,0 +1,33 @@
+module PolyglotIos
+  module Serializer
+    class Translation
+      class << self
+
+        def write(translation_keys, language, translations_path, use_old_naming = false)
+          translations = extract_translations(translation_keys, language)
+
+          data = translations
+            .sort
+            .map { |key, value| "\"#{key}\" = \"#{value}\";" }
+            .join("\n")
+            .concat("\n")
+            
+          FileUtils.mkdir_p translations_path unless File.exist? translations_path
+          locale_code = language.code(use_old_naming)
+          output_path = File.join(translations_path, "#{locale_code}.strings")
+          File.write(output_path, data)
+        end
+
+        def extract_translations(translation_keys, language)
+          translation_keys.each_with_object({}) do |translation_key, strings|
+            key_name = translation_key.name
+            next if key_name.nil?
+            strings[key_name] = translation_key.clean_translation(language)
+          end
+        end
+
+      end
+    end
+  end
+end
+  

data/lib/ios_polyglot_cli/version.rb

@@ -0,0 +1,3 @@
+module PolyglotIos
+  VERSION = '2.0.1'.freeze
+end

data/lib/ios_polyglot_cli.rb

@@ -0,0 +1,42 @@
+# Parsing
+require 'yaml'
+require 'osx_keychain'
+require 'erb'
+require 'active_support/core_ext/hash/indifferent_access'
+
+# Helpers
+require 'ios_polyglot_cli/helpers/depaginate'
+require 'ios_polyglot_cli/helpers/terminal'
+require 'ios_polyglot_cli/helpers/general'
+
+# JSON API Resources
+require 'json_api_client'
+require 'ios_polyglot_cli/api/base'
+require 'ios_polyglot_cli/api/language'
+require 'ios_polyglot_cli/api/project'
+require 'ios_polyglot_cli/api/session'
+require 'ios_polyglot_cli/api/translation'
+require 'ios_polyglot_cli/api/translation_key'
+
+# File Accessors
+require 'ios_polyglot_cli/io/token'
+require 'ios_polyglot_cli/io/config'
+
+# Serializers
+require 'ios_polyglot_cli/serializers/translations/translations_serializer'
+require 'ios_polyglot_cli/serializers/languages/languages_serializer_objc'
+require 'ios_polyglot_cli/serializers/languages/languages_serializer_swift'
+require 'ios_polyglot_cli/serializers/sources/sources_serializer_swift'
+
+# Commands
+require 'ios_polyglot_cli/commands/login'
+require 'ios_polyglot_cli/commands/setup'
+require 'ios_polyglot_cli/commands/pull'
+
+# Error Handler
+require 'ios_polyglot_cli/error_handler'
+require 'ios_polyglot_cli/version'
+
+module PolyglotIos
+
+end