c11n 0.0.1

data/lib/c11n/exporter/google_drive.rb

@@ -0,0 +1,40 @@
+require 'c11n/external/google_drive_driver'
+require 'c11n/types'
+
+module C11n
+  module Exporter
+    class GoogleDrive
+      def initialize(options = {})
+        @driver = C11n::External::GoogleDriveDriver.new(options)
+      end
+
+      def table
+        @table ||= C11n::Table.new(@driver.table)
+      end
+
+      def export(translations, locale)
+        translations.translations_for(locale).each do |key, translation|
+          serialized_translation = serialize(translation, translations.types[key])
+          table.set(locale, key, serialized_translation, type: translations.types[key], category: translations.categories[key])
+        end
+
+        export_table(table)
+      end
+
+      def export_table(table)
+        @driver.write_table(table.rows)
+      end
+
+      private
+
+      def serialize(value, type = nil)
+        case type
+        when C11n::Types::ARRAY
+          value.join("\n\n")
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/c11n/exporter/ios.rb

@@ -0,0 +1,21 @@
+module C11n
+  module Exporter
+    class Ios
+      def initialize(options = {})
+        @path = options[:path]
+      end
+
+      def export(translations, locale)
+        file.print(translations.translations_for(locale).map do |key, translation|
+          "\"#{key}\" = \"#{translation}\";"
+        end.join("\n"))
+
+        file.close
+      end
+
+      def file
+        @file ||= File.new(@path, 'w')
+      end
+    end
+  end
+end

data/lib/c11n/exporter/yaml.rb

@@ -0,0 +1,26 @@
+require 'c11n/conversion/composed_key_deserializer'
+
+module C11n
+  module Exporter
+    class Yaml
+      def initialize(options = {})
+        @base_path = options[:base_path]
+        @path = options[:path] unless @base_path
+      end
+
+      def path_for(locale)
+        @path || "#{@base_path}/#{locale}.yml"
+      end
+
+      def file
+        @file ||= File.new(@path, 'w')
+      end
+
+      def export(translations, locale)
+        deserialized_translations = C11n::Conversion::ComposedKeyDeserializer.new(translations.translations_for(locale)).deserialize
+        file.print(YAML.dump(locale => deserialized_translations))
+        file.close
+      end
+    end
+  end
+end

data/lib/c11n/external/google_drive_driver.rb

@@ -0,0 +1,64 @@
+require 'google_drive'
+
+module C11n
+  module External
+    class GoogleDriveDriver
+      attr_accessor :email, :password, :spreadsheet_key, :worksheet_number
+
+      def initialize(options = {})
+        load_from_options(options)
+        load_configuration
+      end
+
+      def load_from_options(options)
+        @email = options[:email]
+        @password = options[:password]
+        @spreadsheet_key = options[:spreadsheet_key]
+        @worksheet_number = options[:worksheet_number]
+      end
+
+      def load_configuration
+        @email ||= C11n::Configuration.instance.external(:google_drive)[:email]
+        @password ||= C11n::Configuration.instance.external(:google_drive)[:password]
+        @spreadsheet_key ||= C11n::Configuration.instance.external(:google_drive)[:spreadsheet_key]
+        @worksheet_number ||= C11n::Configuration.instance.external(:google_drive)[:worksheet_number]
+      end
+
+      def connection
+        @connection ||= ::GoogleDrive.login(@email, @password)
+      end
+
+      def worksheet
+        @worksheet ||= spreadsheet.worksheets[@worksheet_number]
+      end
+
+      def spreadsheet
+        @spreadsheet ||= connection.spreadsheet_by_key(@spreadsheet_key)
+      end
+
+      def table
+        raw_table = []
+
+        for row in 1..worksheet.num_rows
+          raw_table[row - 1] ||= []
+
+          for col in 1..worksheet.num_cols
+            raw_table[row - 1][col - 1] ||= worksheet[row, col]
+          end
+        end
+
+        raw_table
+      end
+
+      def write_table(table)
+        table.each_with_index do |row, row_index|
+          row.each_with_index do |column, column_index|
+            worksheet[row_index + 1, column_index + 1] = column if column
+          end
+        end
+
+        worksheet.save
+      end
+    end
+  end
+end

data/lib/c11n/importer/android.rb

@@ -0,0 +1,41 @@
+require 'nokogiri'
+require 'c11n/types'
+
+module C11n
+  module Importer
+    class Android
+      attr_reader :types, :categories
+
+      def initialize(options = {})
+        @path = options[:path]
+        @locale = options[:locale]
+        @types = {}
+        @categories = {}
+      end
+
+      def file
+        File.open(@path, 'r')
+      end
+
+      def document
+        Nokogiri::XML(file)
+      end
+
+      def import
+        { @locale.to_sym => to_hash }
+      end
+
+      def to_hash
+        document.at_xpath('resources').elements.inject({}) do |result, element|
+          if element.name == 'string'
+            @types[element['name']] = C11n::Types::CDATA if element.children.any? { |child| child.cdata? }
+            result.merge(element['name'] => element.text.strip)
+          elsif element.name == 'string-array'
+            @types[element['name']] = C11n::Types::ARRAY
+            result.merge(element['name'] => element.elements.map(&:text))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/c11n/importer/google_drive.rb

@@ -0,0 +1,47 @@
+require 'c11n/external/google_drive_driver'
+require 'c11n/table'
+
+module C11n
+  module Importer
+    class GoogleDrive
+      def initialize(options = {})
+        @driver = C11n::External::GoogleDriveDriver.new(options)
+      end
+
+      def table
+        @table ||= C11n::Table.new(@driver.table)
+      end
+
+      def import
+        deserialized = {}
+
+        table.to_hash.each do |locale, translations|
+          deserialized[locale] = translations.inject({}) do |result, key_and_translation|
+            result.merge key_and_translation.first => deserialize(key_and_translation.last, types[key_and_translation.first])
+          end
+        end
+
+        deserialized
+      end
+
+      def categories
+        {}
+      end
+
+      def types
+        table.types
+      end
+
+      private
+
+      def deserialize(value, type = nil)
+        case type
+        when C11n::Types::ARRAY
+          value.split("\n\n")
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/c11n/importer/ios.rb

@@ -0,0 +1,36 @@
+module C11n
+  module Importer
+    class Ios
+      attr_reader :types, :categories
+
+      def initialize(options = {})
+        @path = options[:path]
+        @locale = options[:locale]
+        @types = {}
+        @categories = {}
+      end
+
+      def import
+        result = {}
+
+        file.each_line do |line|
+          result.merge parse(line)
+        end
+
+        result
+      end
+
+      def file
+        File.open(@path, 'r')
+      end
+
+      private
+
+      def parse(line)
+        matched_data = line.scan(/"([^"]+)"\s*=\s*"([^"]*)"/).first
+
+        matched_data && { matched_data.first => matched_data.last }
+      end
+    end
+  end
+end

data/lib/c11n/importer/yaml.rb

@@ -0,0 +1,42 @@
+require 'yaml'
+require 'c11n/conversion/serializer'
+require 'c11n/types'
+
+module C11n
+  module Importer
+    class Yaml
+      def initialize(options = {})
+        @base_path = options[:base_path]
+        @path = options[:path]
+        @types = {}
+      end
+
+      def path_for(locale)
+        @path || "#{@base_path}/#{locale}.yml"
+      end
+
+      def file
+        File.open(@path, 'r')
+      end
+
+      def import
+        raw_yaml = YAML.load(file.read)
+        translations = C11n::Conversion::Serializer.new(raw_yaml.values.first).serialize
+
+        translations.each do |key, translation|
+          @types[key] = C11n::Types::ARRAY if translation.is_a?(Array)
+        end
+
+        { raw_yaml.keys.first => translations }
+      end
+
+      def categories
+        {}
+      end
+
+      def types
+        @types
+      end
+    end
+  end
+end

data/lib/c11n/synchronizer.rb

@@ -0,0 +1,58 @@
+require 'c11n/configuration'
+require 'c11n/translations'
+require 'c11n/importer/google_drive'
+require 'c11n/exporter/google_drive'
+require 'c11n/synchronizer/ios'
+require 'c11n/synchronizer/android'
+require 'c11n/synchronizer/rails'
+
+module C11n
+  class Synchronizer
+    def project
+      @project ||= case @configuration.type
+      when 'ios'
+        C11n::Synchronizer::Ios.new(@configuration.to_hash)
+      when 'android'
+        C11n::Synchronizer::Android.new(@configuration.to_hash)
+      when 'rails'
+        C11n::Synchronizer::Rails.new(@configuration.to_hash)
+      end
+    end
+
+    def initialize(options = {})
+      @configuration = options[:configuration]
+      @translations = C11n::Translations.new
+    end
+
+    def google_drive_importer
+      @google_drive_importer ||= C11n::Importer::GoogleDrive.new
+    end
+
+    def google_drive_exporter
+      @google_drive_exporter ||= C11n::Exporter::GoogleDrive.new
+    end
+
+    def upload
+      project.importers.each do |locale, importer|
+        @translations.import_with(importer)
+        @translations.export_with(google_drive_exporter, locale)
+      end
+    end
+
+    def download
+      @translations.import_with(google_drive_importer)
+
+      project.exporters.each do |locale, exporter|
+        @translations.export_with(exporter, locale)
+      end
+    end
+
+    def setup
+      schema = [C11n::Table::CATEGORY_COLUMN, C11n::Table::KEY_COLUMN, C11n::Table::TYPE_COLUMN] + project.importers.keys.map(&:to_s)
+
+      table_with_schema = C11n::Table.new([schema])
+
+      google_drive_exporter.export_table(table_with_schema)
+    end
+  end
+end

data/lib/c11n/synchronizer/android.rb

@@ -0,0 +1,50 @@
+require 'c11n/importer/android'
+require 'c11n/exporter/android'
+
+module C11n
+  class Synchronizer
+    class Android
+      RESOURCES = 'res'
+      BASE_PATTERN = /^values-?/
+      FILE_NAME = 'strings.xml'
+
+      def initialize(options = {})
+        @project_root = options[:root]
+        @default_locale = options[:default_locale]
+      end
+
+      def importers
+        @importers ||= Hash[localization_files.map do |locale, file_path|
+          [locale, C11n::Importer::Android.new(path: file_path, locale: locale)]
+        end]
+      end
+
+      def exporters
+        @exporters ||= Hash[localization_files.map do |locale, file_path|
+          [locale, C11n::Exporter::Android.new(path: file_path)]
+        end]
+      end
+
+      def localization_files
+        @localization_files ||= localization_directories.inject({}) do |files, localization_directory|
+          locale = localization_directory.gsub(BASE_PATTERN, '')
+          path = File.join(@project_root, RESOURCES, localization_directory, FILE_NAME)
+
+          files.merge (locale.empty? ? @default_locale : locale.to_sym) => path
+        end
+      end
+
+      def localization_directories
+        @localization_directories ||= Dir.new(File.join(@project_root, RESOURCES)).entries.select { |entry| entry =~ BASE_PATTERN }.select do |entry|
+          Dir.new(File.join(@project_root, RESOURCES, entry)).entries.include?(FILE_NAME)
+        end
+      end
+
+      private
+
+      def locale_for(directory_name)
+        directory_name == BASE_NAME ? @default_locale.to_sym : directory_name.gsub("#{BASE_NAME}-", '').to_sym
+      end
+    end
+  end
+end

data/lib/c11n/synchronizer/ios.rb

@@ -0,0 +1,44 @@
+require 'c11n/importer/ios'
+require 'c11n/exporter/ios'
+
+module C11n
+  class Synchronizer
+    class Ios
+      SUPPORT_FILES = 'support files'
+      LOCALIZABLE = 'Localizable.strings'
+
+      def initiailze(options = {})
+        @project_root = options[:root]
+      end
+
+      def importers
+        @importers ||= Hash[localization_files.map do |locale, file_path|
+          [locale, C11n::Importer::Ios.new(path: file_path, locale: locale)]
+        end]
+      end
+
+      def exporters
+        @exporters ||= Hash[localization_files.map do |locale|
+          [locale, C11n::Exporter::Ios.new(path: file_path)]
+        end]
+      end
+
+      def localization_files
+        @localization_files ||= localization_directories.inject({}) do |files, localization_directory|
+          locale = localization_directory.gsub(/\.lproj$/, '').to_sym
+          path = File.join(@project_root, SUPPORT_FILES, localization_directory, LOCALIZABLE)
+
+          files.merge locale => path
+        end
+      end
+
+      def locales
+        localization_directories.map { |directory| directory.gsub(/\.lproj$/, '') }.map(&:to_sym)
+      end
+
+      def localization_directories
+        @localization_directories ||= Dir.new(File.join(@project_root, SUPPORT_FILES)).entries.select { |entry| entry =~ /lproj$/ }
+      end
+    end
+  end
+end