c11n 0.0.1

data/lib/c11n/synchronizer/rails.rb

@@ -0,0 +1,41 @@
+require 'c11n/translations'
+require 'c11n/importer/yaml'
+require 'c11n/exporter/yaml'
+
+module C11n
+  class Synchronizer
+    class Rails
+      def initialize(options = {})
+        @project_root = options[:root]
+      end
+
+      def importers
+        @importers ||= Hash[localization_files.map do |locale, file_path|
+          [locale, C11n::Importer::Yaml.new(path: file_path)]
+        end]
+      end
+
+      def exporters
+        @exporters ||= Hash[localization_files.map do |locale, file_path|
+          [locale, C11n::Exporter::Yaml.new(path: file_path)]
+        end]
+      end
+
+      def localization_files
+        Dir.new(locales_parent_directory_path).entries.select { |entry| entry =~ /\.yml$/ }.inject({}) do |files, entry|
+          files.merge locale_for(entry) => File.join(locales_parent_directory_path, entry)
+        end
+      end
+
+      def locales_parent_directory_path
+        File.join(@project_root, 'config/locales')
+      end
+
+      private
+
+      def locale_for(localization_file)
+        localization_file.gsub(/\.yml$/, '').to_sym
+      end
+    end
+  end
+end

data/lib/c11n/table.rb

@@ -0,0 +1,131 @@
+require 'c11n/conversion/plain_deserializer'
+
+module C11n
+  # Translations in tabular form. The schema of translations table must match
+  # to the schema specified below:
+  #
+  #   1. If category information exists
+  #
+  #         [Category] [Key] [Locale 1] [Locale 2] ... [Locale N]
+  #
+  #   2. If category information does not exist
+  #
+  #         [Key] [Locale 1] [Locale 2] ... [Locale N]
+  #
+  # Columns composing the schema must appear on the first row of the sheet.
+  class Table
+    CATEGORY_COLUMN = 'Category'.freeze
+    TYPE_COLUMN = 'Type'.freeze
+    KEY_COLUMN = 'Key'.freeze
+
+    def initialize(raw_table, options = {})
+      @raw_table = raw_table
+      @deserializer_class = options[:deserializer_class] || C11n::Conversion::PlainDeserializer
+      @categories = {}
+      @types = {}
+    end
+
+    # Returns key-value mappings for specified locale as an array
+    def table_for(locale)
+      @raw_table[1..-1].map do |columns|
+        if columns
+          key = key_column_from(columns)
+          translation = translation_column_from(columns, locale) || ''
+
+          key ? [key, translation] : nil
+        else
+          nil
+        end
+      end.compact
+    end
+
+    def schema
+      @raw_table[0]
+    end
+
+    def locales
+      has_categories? ? schema[2..-1] : schema[1..-1]
+    end
+
+    def categories
+      {}
+    end
+
+    def types
+      if has_types?
+        @types = @raw_table[1..-1].inject({}) do |types, columns|
+          key = columns[key_column_index]
+          type = columns[type_index]
+
+          types.merge(key => type) if type
+        end
+      else
+        {}
+      end
+    end
+
+    def to_hash
+      Hash[locales.map { |locale| [locale.to_sym, @deserializer_class.new(table_for(locale)).deserialize] }]
+    end
+
+    def rows
+      @raw_table
+    end
+
+    def set(locale, key, translation, options = {})
+      unless locales.map(&:to_s).map(&:downcase).include? locale.to_s.downcase
+        schema[schema.length] = locale
+      end
+
+      row_with_key(key)[locale_index_of(locale)] = translation
+      row_with_key(key)[category_index] = options[:category] if has_categories? && options[:category]
+      row_with_key(key)[type_index] = options[:type] if has_types? && options[:type]
+    end
+
+    private
+
+    def key_column_from(columns)
+      columns[key_column_index]
+    end
+
+    def key_column_index
+      schema.map(&:downcase).index(KEY_COLUMN.downcase)
+    end
+
+    def translation_column_from(columns, locale)
+      columns[locale_index_of(locale)]
+    end
+
+    def locale_index_of(locale)
+      schema.map(&:downcase).index(locale.to_s.downcase)
+    end
+
+    def category_index
+      schema.map(&:downcase).index(CATEGORY_COLUMN.downcase)
+    end
+
+    def type_index
+      schema.map(&:downcase).index(TYPE_COLUMN.downcase)
+    end
+
+    def has_categories?
+      schema.map(&:downcase).include?(CATEGORY_COLUMN.downcase)
+    end
+
+    def has_types?
+      schema.map(&:downcase).include?(TYPE_COLUMN.downcase)
+    end
+
+    def row_with_key(key)
+      @raw_table[1..-1].detect do |row|
+        row[key_column_index].to_s == key.to_s
+      end || @raw_table[@raw_table.length] = new_row_with_key(key)
+    end
+
+    def new_row_with_key(key)
+      [].tap do |row|
+        row[key_column_index] = key
+      end
+    end
+  end
+end

data/lib/c11n/translations.rb

@@ -0,0 +1,49 @@
+require 'c11n/conversion/composed_key_deserializer'
+
+module C11n
+  class Translations
+    attr_reader :categories, :types
+
+    def initialize(options = {})
+      @translations = {}
+      @deserializer_class = options[:deserializer_class] || C11n::Conversion::ComposedKeyDeserializer
+    end
+
+    def add_translation(locale, key, value)
+      translations_for(locale.to_sym)[key] = value
+    end
+
+    def translation(locale, key)
+      translations_for(locale.to_sym)[key]
+    end
+
+    def add_translations(locale, translations)
+      @translations[locale.to_sym] = translations
+    end
+
+    def import_with(importer, given_locale = nil)
+      importer.import.each do |locale, imported|
+        next if given_locale && given_locale.to_sym != locale.to_sym
+
+        add_translations(locale, imported)
+      end
+
+      @categories = importer.categories
+      @types = importer.types
+
+      self
+    end
+
+    def export_with(exporter, locale)
+      exporter.export(self, locale)
+    end
+
+    def translations_for(locale)
+      @translations[locale.to_sym] ||= {}
+    end
+
+    def to_hash
+      @translations
+    end
+  end
+end

data/lib/c11n/types.rb

@@ -0,0 +1,6 @@
+module C11n
+  module Types
+    ARRAY = 'Array'.freeze
+    CDATA = 'CDATA'.freeze
+  end
+end

data/lib/c11n/version.rb

@@ -0,0 +1,3 @@
+module C11n
+  VERSION = '0.0.1'
+end

data/spec/c11n/configuration_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe C11n::Configuration do
+  let(:configuration) { C11n::Configuration.new }
+
+  describe '#method_missing' do
+    it { expect { configuration.some_key = 'value' }.not_to raise_error }
+
+    context 'when a setter method is invoked before' do
+      let(:value) { 'value' }
+      before { configuration.some_key = value }
+
+      it { expect(configuration.configurations[:some_key]).to eq(value) }
+    end
+
+    context 'when a getter method is invoked' do
+      context 'when configurations has an exact match' do
+        let(:value) { 'configuration value' }
+        before { configuration.configurations[:some_key] = value }
+
+        it { expect(configuration.some_key).to eq(value) }
+      end
+
+      context 'when configurations does not have an exact match' do
+        it { expect { configuration.some_key }.to raise_error(NoMethodError) }
+      end
+    end
+  end
+
+  describe '#external' do
+    context 'when it is invoked with a block' do
+      it { expect(configuration.external(:google_drive) { |config| config.some = 'thing' }).to be_kind_of(C11n::Configuration) }
+    end
+
+    context 'when it is invoked without a block' do
+      context 'when an external service is configured before' do
+        before { configuration.external(:google_drive) { |config| config.some = 'thing' } }
+
+        it { expect(configuration.externals[:google_drive]).not_to be_nil }
+      end
+
+      context 'when no external service with matching name is configured before' do
+        it { expect { configuration.external(:google_drive) }.to raise_error(C11n::Configuration::NotConfigured) }
+      end
+    end
+  end
+
+  describe '#load_from_hash' do
+    let(:google_config) { { other: 'things' } }
+    let(:config_hash) { { some: 'thing', external: { google: google_config } } }
+
+    it { expect { configuration.load_from_hash(config_hash) }.not_to raise_error }
+
+    context 'when it is loaded' do
+      before { configuration.load_from_hash(config_hash) }
+
+      it { expect(configuration.some).to eq('thing') }
+      it { expect(configuration.external(:google).to_hash).to eq(google_config) }
+    end
+  end
+end

data/spec/c11n/conversion/composed_key_deserializer_spec.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe C11n::Conversion::ComposedKeyDeserializer do
+  describe '#deserialize' do
+    let(:source) { [['general.title', '너말고 니친구'], ['views.confirmations.title', '너말고 니친구 메일 인증'], ['views.confirmations.send', '확인 메일 다시 받기'], ['views.passwords.title', '패스워드 리셋하기']] }
+    let(:result) { { general: { title: '너말고 니친구' }, views: { confirmations: { title: '너말고 니친구 메일 인증', send: '확인 메일 다시 받기' }, passwords: { title: '패스워드 리셋하기' } } } }
+    let(:deserializer) { C11n::Conversion::ComposedKeyDeserializer.new(source) }
+
+    it { expect { deserializer.deserialize }.not_to raise_error }
+    it { expect(deserializer.deserialize).to eq(result) }
+  end
+
+  describe '#path_for' do
+    let(:path) { 'views.confirmations.title' }
+    let(:deserializer) { C11n::Conversion::ComposedKeyDeserializer.new([]) }
+
+    it { expect(deserializer.send(:path_for, path)).to eq([:views, :confirmations, :title]) }
+  end
+
+  describe '#create_or_get_leaf_node_for' do
+    let(:path) { [:views, :confirmations, :title] }
+    let(:deserializer) { C11n::Conversion::ComposedKeyDeserializer.new([]) }
+
+    before { deserializer.create_or_get_leaf_node_for(path) }
+
+    it { expect(deserializer.translations[:views]).not_to be_nil }
+    it { expect(deserializer.translations[:views][:confirmations]).not_to be_nil }
+  end
+end

data/spec/c11n/conversion/serializer_spec.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+#
+require 'spec_helper'
+
+describe C11n::Conversion::Serializer do
+  describe '#serialize' do
+    let(:source) { { general: { title: '너말고 니친구' }, views: { confirmations: { title: '너말고 니친구 메일 인증', send: '확인 메일 다시 받기' }, passwords: { title: '패스워드 리셋하기' } } } }
+    let(:result) { { 'general.title' => '너말고 니친구', 'views.confirmations.title' => '너말고 니친구 메일 인증', 'views.confirmations.send' => '확인 메일 다시 받기', 'views.passwords.title' => '패스워드 리셋하기' } }
+    let(:serializer) { C11n::Conversion::Serializer.new(source) }
+
+    it { expect(serializer.serialize).to eq(result) }
+  end
+
+  describe '#serialized_translations_for' do
+    let(:prefix) { 'prefix' }
+    let(:serializer) { C11n::Conversion::Serializer.new([]) }
+
+    context 'when depth of recursion is 0' do
+      let(:translations) { { hello: 'Hello', world: 'World' } }
+      let(:result) { [C11n::Conversion::Serializer::Pair.new('prefix.hello', 'Hello'), C11n::Conversion::Serializer::Pair.new('prefix.world', 'World')] }
+
+      it { expect(serializer.send(:serialized_translations_for, prefix, translations)).to eq(result) }
+    end
+
+    context 'when depth of recursion is larger than 0' do
+      let(:translations) { { recursive: { hello: 'Hello', world: 'World' } } }
+      let(:result) { [C11n::Conversion::Serializer::Pair.new('prefix.recursive.hello', 'Hello'), C11n::Conversion::Serializer::Pair.new('prefix.recursive.world', 'World')] }
+
+      it { expect(serializer.send(:serialized_translations_for, prefix, translations)).to eq(result) }
+    end
+  end
+end

data/spec/c11n/table_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe C11n::Table do
+  let(:raw_table) do
+    [
+      ['Key', 'ko', 'en'],
+      ['attribute_a', 'korean_a', 'english_a'],
+      ['attribute_b', 'korean_b', 'english_b']
+    ]
+  end
+
+  let(:table) { C11n::Table.new(raw_table) }
+
+  describe '#table_for' do
+    it { expect(table.table_for(:ko)).to eq([['attribute_a', 'korean_a'], ['attribute_b', 'korean_b']]) }
+    it { expect(table.table_for(:en)).to eq([['attribute_a', 'english_a'], ['attribute_b', 'english_b']]) }
+  end
+end

data/spec/c11n/translations_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe C11n::Translations do
+  let(:translations) { C11n::Translations.new }
+  let(:translations_hash) { translations.to_hash }
+
+  describe '#translations_for' do
+    it { expect(translations.translations_for(:en)).not_to be_nil }
+    it { expect(translations.translations_for(:en)).to be_empty }
+    it { expect(translations.translations_for(:en)).to eq({}) }
+  end
+
+  describe '#add_translation' do
+    let(:key) { 'attribute_a' }
+    let(:value) { 'a' }
+    before { translations.add_translation(:en, key, value) }
+
+    it { expect(translations_hash[:en][key]).to eq(value) }
+  end
+
+  describe '#add_translations' do
+    let(:raw_translations) { { 'attribute_a' => 'a', 'attribute_b' => 'b' } }
+
+    before { translations.add_translations(:en, raw_translations) }
+
+    it { expect(translations_hash[:en]).to eq(raw_translations) }
+  end
+
+  describe '#import_with' do
+    let(:raw_translations) { { 'attribute_a' => 'a', 'attribute_b' => 'b' } }
+    let(:mock_importer) { double(import: { en: raw_translations }, categories: {}, types: {}) }
+
+    it { expect { translations.import_with(mock_importer) }.not_to raise_error }
+
+    context 'when it is done before' do
+      before { translations.import_with(mock_importer) }
+
+      it { expect(translations_hash[:en]).to eq(raw_translations) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'c11n'
+
+Dir['./lib/**/*.rb'].each { |f| require f }

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: c11n
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Inbeom Hwang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google_drive
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Imports/exports i18n translations from/to Google Drive Spreadsheet for
+  easier collaboration.
+email:
+- hwanginbeom@gmail.com
+executables:
+- c11n
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/c11n
+- c11n.gemspec
+- lib/c11n.rb
+- lib/c11n/configuration.rb
+- lib/c11n/conversion/composed_key_deserializer.rb
+- lib/c11n/conversion/plain_deserializer.rb
+- lib/c11n/conversion/serializer.rb
+- lib/c11n/executable/runner.rb
+- lib/c11n/exporter/android.rb
+- lib/c11n/exporter/google_drive.rb
+- lib/c11n/exporter/ios.rb
+- lib/c11n/exporter/yaml.rb
+- lib/c11n/external/google_drive_driver.rb
+- lib/c11n/importer/android.rb
+- lib/c11n/importer/google_drive.rb
+- lib/c11n/importer/ios.rb
+- lib/c11n/importer/yaml.rb
+- lib/c11n/synchronizer.rb
+- lib/c11n/synchronizer/android.rb
+- lib/c11n/synchronizer/ios.rb
+- lib/c11n/synchronizer/rails.rb
+- lib/c11n/table.rb
+- lib/c11n/translations.rb
+- lib/c11n/types.rb
+- lib/c11n/version.rb
+- spec/c11n/configuration_spec.rb
+- spec/c11n/conversion/composed_key_deserializer_spec.rb
+- spec/c11n/conversion/serializer_spec.rb
+- spec/c11n/table_spec.rb
+- spec/c11n/translations_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Manage i18n for your projects using Google Drive.
+test_files:
+- spec/c11n/configuration_spec.rb
+- spec/c11n/conversion/composed_key_deserializer_spec.rb
+- spec/c11n/conversion/serializer_spec.rb
+- spec/c11n/table_spec.rb
+- spec/c11n/translations_spec.rb
+- spec/spec_helper.rb
+has_rdoc: