aigu 0.3.1 → 0.4

data/lib/aigu/cli.rb

@@ -10,7 +10,7 @@ module Aigu
     end
 
     def run
-      service_name = "#{@command}er".capitalize
+      service_name = "#{@command}er".split('_').map(&:capitalize).join
 
       begin
         service_class = Aigu.const_get(service_name)
@@ -28,22 +28,18 @@ module Aigu
     def parse_options_from_yaml(options)
       file = File.join(Dir.pwd, '.aigu.yml')
 
-      if File.exists?(file)
+      if File.exist?(file)
         # Load YAML content
         content = YAML.load_file(file)
 
-        # Symbolize keys
-        content = content.reduce({}) do |memo, (key, value)|
-          memo.merge! key.to_sym => value
-        end
-
-        # Merge with existing options
-        options = options.merge(content)
+        # Symbolize keys and merge with existing options
+        options = options.merge(content.symbolize_keys)
       end
 
       options
     end
 
+    # rubocop:disable Metrics/MethodLength
     def parse_options_from_arguments(options)
       OptionParser.new do |opts|
         opts.banner = 'Usage: aigu [options]'
@@ -72,6 +68,14 @@ module Aigu
           options[:ignore] = ignore.split(',')
         end
 
+        opts.on('--accent-api-key=', 'Accent API key') do |key|
+          options[:'accent-api-key'] = key
+        end
+
+        opts.on('--accent-url=', 'Accent URL (ex: http://accent.mirego.com)') do |url|
+          options[:'accent-url'] = url
+        end
+
         opts.on_tail('-h', '--help', 'Show this message') do
           puts opts
           exit
@@ -81,5 +85,6 @@ module Aigu
 
       options
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/aigu/core_exporter.rb

@@ -0,0 +1,82 @@
+module Aigu
+  class CoreExporter
+    ENUM_LINE_REGEX = /^\s*(?<key>\w+)\s?\("(?<value_en>.*)",\s?"(?<value_fr>.*)"\),?\s$/
+
+    def initialize(opts = {})
+      @output_file = opts[:'output-file']
+      @input_directory = opts[:'input-directory']
+      @locale = opts[:locale]
+      @ignore = opts[:ignore]
+    end
+
+    def process!
+      puts "Generating Accent JSON file `#{@output_file}` based on Core Java Enum files in `#{@input_directory}` directory"
+
+      if @ignore
+        print 'Ignoring '
+        puts @ignore.join(', ')
+      end
+
+      puts '---'
+
+      build_output
+      write_json_file
+
+      puts '---'
+      puts 'Done'
+    end
+
+  protected
+
+    def build_output
+      @output = {}
+
+      pattern = File.join(@input_directory, '**', 'CoreLocalizedStrings.java')
+      Dir[pattern].each do |filepath|
+        if ignored_filepath?(filepath)
+          puts "Ignoring #{filepath}"
+        else
+          puts "Processing #{filepath}"
+
+          content = File.open(filepath, 'rb:bom|utf-8').read
+
+          content = parse_java_file(content, @locale)
+          @output.merge! content
+        end
+      end
+
+      @output
+    end
+
+    def write_json_file
+      file_path = @output_file
+      puts "Generating #{file_path}"
+      FileUtils.mkdir_p(File.dirname(file_path))
+
+      File.open(file_path, 'w+') do |file|
+        file << JSON.pretty_generate(JSON.parse(@output.to_json))
+      end
+    end
+
+    def parse_java_file(java_file_content, locale = '')
+      string_hash = {}
+
+      java_file_content.each_line do |line|
+        next if line.include?('/* <-- !!LOCALIZED STRINGS!! */')
+
+        match_data = line.match(ENUM_LINE_REGEX)
+        if match_data
+          string_hash[match_data[:key]] = locale == 'fr' ? match_data[:value_fr] : match_data[:value_en]
+        end
+      end
+
+      string_hash
+    end
+
+    def ignored_filepath?(filepath)
+      @ignore && @ignore.any? do |pattern|
+        return File.fnmatch(pattern, filepath, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+      end
+    end
+  end
+end

data/lib/aigu/core_importer.rb

@@ -0,0 +1,82 @@
+module Aigu
+  class CoreImporter
+    ENUM_LINE_REGEX = /^\s*(?<key>\w+)\s?\("(?<value_en>.*)",\s?"(?<value_fr>.*)"\)(?<comma>,?)\s$/
+
+    def initialize(opts = {})
+      @input_file = opts[:'input-file']
+      @output_directory = opts[:'output-directory']
+      @locale = opts[:locale]
+    end
+
+    def process!
+      puts "Updating Core Java Enum files in `#{@output_directory}` based on Accent-generated `#{@input_file}` file"
+      puts '---'
+
+      parse_json
+      read_java
+      @java_content = update_in_memory(@java_content, @object, @locale)
+      write_java
+
+      puts '---'
+      puts 'Done'
+    end
+
+  protected
+
+    def parse_json
+      json = File.read(@input_file)
+      @object = JSON.parse(json)
+    end
+
+    def read_java
+      pattern = File.join(@output_directory, '**', 'CoreLocalizedStrings.java')
+      @filepath = Dir[pattern].first
+      puts "Processing #{@filepath}"
+
+      @java_content = File.open(@filepath, 'rb:bom|utf-8').read
+    end
+
+    def write_java
+      puts "Updating #{@filepath}"
+      File.open(@filepath, 'w+:bom|utf-8') do |file|
+        file << @java_content
+      end
+    end
+
+    def update_in_memory(java_file_content, content, locale = '')
+      in_section = false
+      new_content = ''
+
+      java_file_content.each_line do |line|
+        if line.include?('/* !!LOCALIZED STRINGS!! --> */')
+          in_section = true
+        elsif line.include?('/* <-- !!LOCALIZED STRINGS!! */')
+          in_section = false
+        end
+
+        if in_section
+          line_content = build_line_inside_localized_section(line, content, locale)
+        end
+        new_content << (line_content || line)
+      end
+      new_content
+    end
+
+    def build_line_inside_localized_section(line, content, locale)
+      line_content = nil
+      match_data = line.match(ENUM_LINE_REGEX)
+
+      if match_data
+        key = match_data[:key]
+
+        line_content = "    #{key}(\""
+        line_content << (locale != 'fr' ? content[key] : match_data[:value_en])
+        line_content << '", "'
+        line_content << (locale == 'fr' ? content[key] : match_data[:value_fr])
+        line_content << "\")#{match_data[:comma]}\n"
+      end
+
+      line_content
+    end
+  end
+end

data/lib/aigu/exporter.rb

@@ -66,9 +66,7 @@ module Aigu
     end
 
     def flattenize_content_values(hash)
-      result = {}
-
-      hash.reduce({}) do |memo, (key, value)|
+      hash.each_with_object({}) do |(key, value), memo|
         if value.is_a?(Array)
           value.each_with_index do |array_value, index|
             tainted_key = "#{key}___KEY___#{index}"
@@ -77,8 +75,6 @@ module Aigu
         else
           memo[key] = sanitize_value_to_string(value)
         end
-
-        memo
       end
     end
 

data/lib/aigu/extensions/hash.rb

@@ -4,4 +4,10 @@ class Hash
       hash[key] = recursive
     end
   end
+
+  def symbolize_keys
+    reduce({}) do |memo, (key, value)|
+      memo.merge! key.to_sym => value
+    end
+  end
 end

data/lib/aigu/importer.rb

@@ -68,7 +68,7 @@ module Aigu
     end
 
     def expand_content_values(content)
-      content.reduce({}) do |memo, (key, value)|
+      content.each_with_object({}) do |(key, value), memo|
         match_data = key.match(ARRAY_REGEX)
 
         if match_data
@@ -79,8 +79,6 @@ module Aigu
         else
           memo[key] = sanitize_string_to_value(value)
         end
-
-        memo
       end
     end
 

data/lib/aigu/ios_exporter.rb

@@ -0,0 +1,165 @@
+module Aigu
+  class IosExporter
+    PROP_LINE_REGEX = /^\s*"(?<key>.+)"\s?=\s?"(?<value>.*)";\s$/
+
+    DICT_DICT_OPEN_REGEX = /^\s*<dict>\s*$/
+    DICT_DICT_CLOSE_REGEX = /^\s*<\/dict>\s*$/
+    DICT_KEY_REGEX = /^\s*<key>(?<text>.*)<\/key>\s*$/
+    DICT_STRING_REGEX = /^\s*<string>(?<text>.*)<\/string>\s*$/
+
+    def initialize(opts = {})
+      @output_file = opts[:'output-file']
+      @input_directory = opts[:'input-directory']
+      @locale = opts[:locale]
+      @ignore = opts[:ignore]
+    end
+
+    def process!
+      puts "Generating Accent JSON file `#{@output_file}` based on IOS strings files in `#{@input_directory}` directory"
+
+      if @ignore
+        print 'Ignoring '
+        puts @ignore.join(', ')
+      end
+
+      puts '---'
+
+      build_output
+      write_json_file
+
+      puts '---'
+      puts 'Done'
+    end
+
+  protected
+
+    def build_output
+      @output = {}
+      @locale || @locale = 'en'
+
+      pattern = File.join(@input_directory, "#{@locale}.lproj", 'Localizable.strings')
+      filepath = Dir[pattern].first
+
+      assign_output_from_file!(filepath)
+
+      pattern = File.join(@input_directory, "#{@locale}.lproj", 'Localizable.stringsdict')
+      filepath = Dir[pattern].first
+
+      assign_output_from_file!(filepath)
+
+      @output
+    end
+
+    def assign_output_from_file!(filepath)
+      if filepath
+        puts "Processing #{filepath}"
+
+        file_content = File.open(filepath, 'rt').read
+
+        @output.merge! parse_strings_file(file_content)
+      else
+        puts 'Strings file not found'
+      end
+    end
+
+    def parse_strings_file(file_content)
+      file_content.each_line.each_with_object({}) do |line, string_hash|
+        match_data = line.match(PROP_LINE_REGEX)
+
+        if match_data
+          string_hash[match_data[:key]] = replace_string_interpolations(match_data[:value])
+        end
+      end
+    end
+
+    # This takes a string and replaces Android interpolations to iOS interpolations.
+    # Note that %s works on iOS but it doesn’t work with NSString because they’re objects.
+    # To make it work with objects, we need to convert all %s to %@.
+    # Example: 'Android interpolation %s or %1$s' => 'iOS interpolation %@ or %1$@'.
+    def replace_string_interpolations(string)
+      string.gsub(/%([0-9]+\$)?s/, '%\\1@')
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/BlockNesting
+    def parse_stringsdict_file(file_content)
+      # Quite custom parsing to reuse same logic on importer
+      # Assume a clean structure of file to KISS
+
+      in_root_dict = false
+      bundle_key = nil
+      string_key = nil
+      in_string_dict = false
+      plural_key = nil
+
+      file_content.each_line.each_with_object({}) do |line, string_hash|
+        if line.match(DICT_DICT_OPEN_REGEX)
+          # <dict>
+          if !in_root_dict
+            in_root_dict = true
+          elsif string_key
+            in_string_dict = true
+          end
+        elsif line.match(DICT_DICT_CLOSE_REGEX)
+          # </dict>
+          if in_string_dict
+            in_string_dict = false
+            string_key = nil
+            plural_key = nil
+          elsif bundle_key
+            bundle_key = nil
+          else
+            in_root_dict = false
+          end
+        elsif matched_data = line.match(DICT_KEY_REGEX)
+          # <key>..</key>
+          if in_root_dict
+            if bundle_key
+              if string_key
+                plural_key = matched_data[:text]
+              else
+                string_key = matched_data[:text]
+              end
+            else
+              bundle_key = matched_data[:text]
+            end
+          end
+        elsif matched_data = line.match(DICT_STRING_REGEX)
+          # <string>..</string>
+          if string_key && !in_string_dict
+            string_key = nil
+          elsif in_string_dict && plural_key
+            if %w(zero one other).include? plural_key
+              hash_key = "__@DICT__#{bundle_key}__@STRING__#{string_key}__@#{plural_key.upcase}"
+              string_hash[hash_key] = cleanup_input_xml(matched_data[:text])
+            end
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/BlockNesting
+
+    def write_json_file
+      file_path = @output_file
+      puts "Generating #{file_path}"
+      FileUtils.mkdir_p(File.dirname(file_path))
+
+      File.open(file_path, 'w+') do |file|
+        file << JSON.pretty_generate(JSON.parse(@output.to_json))
+      end
+    end
+
+    # Try to fix issue
+    def cleanup_input_xml(xml)
+      replace_html_name(xml, 'quot', '"')
+      replace_html_name(xml, 'amp', '&')
+      replace_html_name(xml, 'apos', "'")
+      replace_html_name(xml, 'lt', '<')
+      replace_html_name(xml, 'gt', '>')
+      xml
+    end
+
+    def replace_html_name(xml, html_name, character)
+      xml.gsub!(/&#{html_name};/, character)
+    end
+  end
+end

data/lib/aigu/ios_importer.rb

@@ -0,0 +1,181 @@
+module Aigu
+  class IosImporter
+    DICT_DICT_OPEN_REGEX = /^\s*<dict>\s*$/
+    DICT_DICT_CLOSE_REGEX = /^\s*<\/dict>\s*$/
+    DICT_KEY_REGEX = /^\s*<key>(?<text>.*)<\/key>\s*$/
+    DICT_STRING_REGEX = /^(?<left>\s*<string>)(?<text>.*)(?<right><\/string>\s*)$/
+
+    def initialize(opts = {})
+      @input_file = opts[:'input-file']
+      @output_directory = opts[:'output-directory']
+      @locale = opts[:locale]
+    end
+
+    def process!
+      puts "Generating IOS strings files in `#{@output_directory}` based on Accent-generated `#{@input_file}` file"
+      puts '---'
+
+      parse_json
+      strings, dict = split_dict
+      write_strings_files(strings)
+      write_stringsdict_file(dict)
+
+      puts '---'
+      puts 'Done'
+    end
+
+  protected
+
+    def parse_json
+      json = File.read(@input_file)
+      @object = JSON.parse(json)
+    end
+
+    def split_dict
+      strings = {}
+      dict = {}
+
+      @object.each_pair do |key, value|
+        match_data = key.match(/^__@DICT__.*/)
+
+        if match_data
+          dict[key] = value
+        else
+          strings[key] = value
+        end
+      end
+
+      [strings, dict]
+    end
+
+    def write_strings_files(content)
+      @locale || @locale = 'en'
+
+      file_path = File.join(@output_directory, "#{@locale}.lproj", 'Localizable.strings')
+      puts "Generating #{file_path}"
+      FileUtils.mkdir_p(File.dirname(file_path))
+
+      File.open(file_path, 'w+:bom|utf-8') do |file|
+        file << format_strings_file(content)
+      end
+    end
+
+    def format_strings_file(content)
+      file_content = ''
+
+      content.each_pair do |key, value|
+        file_content << '"' << key << '" = "' << replace_string_interpolations(value) << '";' << "\n"
+      end
+
+      file_content
+    end
+
+    # This takes a string and replaces iOS interpolations to Android interpolations
+    # so that it is reusable across platforms.
+    # Example: 'iOS interpolation %@ or %1$@' => 'Android interpolation %s or %1$s'.
+    def replace_string_interpolations(string)
+      string.gsub(/%([0-9]+\$)?@/, '%\\1s')
+    end
+
+    def write_stringsdict_file(content)
+      # uses same logic as exporter to parse current file & update in memory
+
+      # read file
+      file_path = File.join(@output_directory, "#{@locale}.lproj", 'Localizable.stringsdict')
+      puts "Updating #{file_path}"
+
+      file_content = File.open(file_path, 'rb:bom|utf-8').read
+
+      # in memory update
+      file_content = update_stringsdict_content(file_content, content)
+
+      # write back
+      File.open(file_path, 'w+:bom|utf-8') do |file|
+        file << file_content
+      end
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/BlockNesting
+    def update_stringsdict_content(file_content, new_hash)
+      # Custom parsing in order to keep the file as-is, with any comments and spaces that dev used
+
+      new_content = ''
+      in_root_dict = false
+      bundle_key = nil
+      string_key = nil
+      in_string_dict = false
+      plural_key = nil
+
+      file_content.each_line do |line|
+        if line.match(DICT_DICT_OPEN_REGEX)
+          # <dict>
+          if !in_root_dict
+            in_root_dict = true
+          elsif string_key
+            in_string_dict = true
+          end
+
+          # dict open lines, keep as is
+          new_content << line
+        elsif line.match(DICT_DICT_CLOSE_REGEX)
+          # </dict>
+          if in_string_dict
+            in_string_dict = false
+            string_key = nil
+            plural_key = nil
+          elsif bundle_key
+            bundle_key = nil
+          else
+            in_root_dict = false
+          end
+
+          # dict close lines, keep as is
+          new_content << line
+        elsif matched_data = line.match(DICT_KEY_REGEX)
+          # <key>..</key>
+          if in_root_dict
+            if bundle_key
+              if string_key
+                plural_key = matched_data[:text]
+              else
+                string_key = matched_data[:text]
+              end
+            else
+              bundle_key = matched_data[:text]
+            end
+          end
+
+          # key lines, keep as is
+          new_content << line
+        elsif matched_data = line.match(DICT_STRING_REGEX)
+          # <string>..</string>
+          if string_key && !in_string_dict
+            string_key = nil
+
+            # useless string lines, keep as is
+            new_content << line
+          elsif in_string_dict && plural_key
+            if %w(zero one other).include? plural_key
+              hash_key = "__@DICT__#{bundle_key}__@STRING__#{string_key}__@#{plural_key.upcase}"
+
+              # replace value, keeps other parts of the line as is
+              new_content << matched_data[:left] << new_hash[hash_key].encode(xml: :text) << matched_data[:right]
+            else
+              # useless string lines, keep as is
+              new_content << line
+            end
+          else
+            # useless string lines, keep as is
+            new_content << line
+          end
+        else
+          # unknown line, keep as is
+          new_content << line
+        end
+      end
+
+      new_content
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/BlockNesting
+  end
+end