i18n_flow 0.1.0

data/lib/i18n_flow/yaml_ast_proxy.rb

@@ -0,0 +1,57 @@
+require 'psych'
+require_relative 'yaml_ast_proxy/node'
+require_relative 'yaml_ast_proxy/mapping'
+require_relative 'yaml_ast_proxy/sequence'
+
+module I18nFlow::YamlAstProxy
+  def self.create(node, parent: nil, scopes: [], file_path: nil)
+    case node
+    when NilClass
+      nil
+    when Node
+      if node.parent == parent \
+        && node.scopes == scopes \
+        && node.file_path == file_path
+        node
+      else
+        node.class.new(node.node,
+          parent:    parent,
+          scopes:    scopes,
+          file_path: file_path,
+        )
+      end
+    when Psych::Nodes::Stream, Psych::Nodes::Document
+      Node.new(node.children.first,
+        parent:    node,
+        scopes:    scopes,
+        file_path: file_path,
+      )
+    when Psych::Nodes::Mapping
+      Mapping.new(node,
+        parent:    parent,
+        scopes:    scopes,
+        file_path: file_path,
+      )
+    when Psych::Nodes::Sequence
+      Sequence.new(node,
+        parent:    parent,
+        scopes:    scopes,
+        file_path: file_path,
+      )
+    else
+      Node.new(node,
+        parent:    parent,
+        scopes:    scopes,
+        file_path: file_path,
+      )
+    end
+  end
+
+  def self.new_root
+    doc = Psych::Nodes::Document.new([], [], true)
+    doc.children << Psych::Nodes::Mapping.new
+    stream = Psych::Nodes::Stream.new
+    stream.children << doc
+    create(stream)
+  end
+end

data/lib/i18n_flow.rb

@@ -0,0 +1,15 @@
+module I18nFlow
+  extend self
+
+  def config
+    @config ||= Configuration.new
+  end
+
+  def configure(&block)
+    config.update(&block)
+  end
+end
+
+require_relative 'i18n_flow/version'
+require_relative 'i18n_flow/configuration'
+require_relative 'i18n_flow/validator'

data/spec/lib/i18n_flow/cli/command_base_spec.rb

@@ -0,0 +1,46 @@
+require 'i18n_flow/cli/command_base'
+
+describe I18nFlow::CLI::CommandBase do
+  let(:command) { I18nFlow::CLI::CommandBase.new([]) }
+
+  describe '#invoke!' do
+    it 'should raise a not implemented error' do
+      expect {
+        command.invoke!
+      }.to raise_error(/implemented/)
+    end
+  end
+
+  describe '#exit_with_message' do
+    let(:message)        { 'a message' }
+    let(:message_regexp) { /a message/ }
+
+    context 'With status code of zero' do
+      let(:status)  { 0 }
+
+      it 'should print a message to stdout and exit' do
+        expect {
+          begin
+            command.exit_with_message(status, message)
+          rescue SystemExit => e
+            expect(e.status).to eq(status)
+          end
+        }.to output(message_regexp).to_stdout
+      end
+    end
+
+    context 'With status code of non-zero' do
+      let(:status)  { 1 }
+
+      it 'should print a message to stderr and exit' do
+        expect {
+          begin
+            command.exit_with_message(status, message)
+          rescue SystemExit => e
+            expect(e.status).to eq(status)
+          end
+        }.to output(message_regexp).to_stderr
+      end
+    end
+  end
+end

data/spec/lib/i18n_flow/cli/help_command_spec.rb

@@ -0,0 +1,13 @@
+require 'i18n_flow/cli/help_command'
+
+describe I18nFlow::CLI::HelpCommand do
+  let(:command) { I18nFlow::CLI::HelpCommand.new([]) }
+
+  describe '#invoke!' do
+    it 'should print help' do
+      expect {
+        command.invoke!
+      }.to output(/Usage/).to_stdout
+    end
+  end
+end

data/spec/lib/i18n_flow/cli/version_command_spec.rb

@@ -0,0 +1,13 @@
+require 'i18n_flow/cli/version_command'
+
+describe I18nFlow::CLI::VersionCommand do
+  let(:command) { I18nFlow::CLI::VersionCommand.new([]) }
+
+  describe '#invoke!' do
+    it 'should print gem version' do
+      expect {
+        command.invoke!
+      }.to output(/v\d+\.\d+.\d+/).to_stdout
+    end
+  end
+end

data/spec/lib/i18n_flow/configuration_spec.rb

@@ -0,0 +1,334 @@
+require 'i18n_flow/configuration'
+
+describe I18nFlow::Configuration do
+  let(:configuration) { I18nFlow::Configuration.new }
+
+  describe '.new' do
+    let(:options) do
+      %i[
+        base_path
+        glob_patterns
+        valid_locales
+        locale_pairs
+        split_max_level
+        split_line_threshold
+      ]
+    end
+
+    it 'should set default values' do
+      options.each do |option|
+        expect(configuration.respond_to?(option)).to be(true)
+        expect(configuration.send(option)).not_to be_nil
+      end
+    end
+  end
+
+  describe '#base_path, #base_path=' do
+    it 'should return an instance of Pathname' do
+      expect(configuration.base_path).to be_a(Pathname)
+    end
+
+    it 'should store an instance of Pathname from a string in the setter' do
+      path = 'foo/bar'
+
+      expect {
+        configuration.base_path = path
+      }.not_to raise_error
+
+      expect(configuration.base_path).to be_a(Pathname)
+      expect(configuration.base_path.to_s).to eq(path)
+    end
+  end
+
+  describe '#glob_patterns, #glob_patterns=' do
+    it 'should return an array' do
+      expect(configuration.glob_patterns).to be_a(Array)
+    end
+
+    it 'should store the given value as an array of strings in the setter' do
+      expect {
+        configuration.glob_patterns = [:'foo.yml']
+      }.not_to raise_error
+
+      expect(configuration.glob_patterns).to eq(['foo.yml'])
+    end
+  end
+
+  describe '#valid_locales, #valid_locales=' do
+    it 'should return an array' do
+      expect(configuration.valid_locales).to be_a(Array)
+    end
+
+    it 'should store the given value as an array of strings in the setter' do
+      expect {
+        configuration.valid_locales = [:en]
+      }.not_to raise_error
+
+      expect(configuration.valid_locales).to eq(['en'])
+    end
+  end
+
+  describe '#locale_pairs, #locale_pairs=' do
+    it 'should return an array' do
+      expect(configuration.locale_pairs).to be_a(Array)
+    end
+
+    it 'should store the given value as an array of strings in the setter' do
+      expect {
+        configuration.locale_pairs = [[:en, :ja]]
+      }.not_to raise_error
+
+      expect(configuration.locale_pairs).to eq([['en', 'ja']])
+    end
+  end
+
+  describe '#linters, #linters=' do
+    it 'should return an array' do
+      expect(configuration.linters).to be_a(Array)
+    end
+
+    it 'should store the given value as an array of symbols in the setter' do
+      expect {
+        configuration.linters = ['foo', 'bar']
+      }.not_to raise_error
+
+      expect(configuration.linters).to eq([:foo, :bar])
+    end
+  end
+
+  describe '#validate!' do
+    context 'base_path' do
+      it 'should raise an error if it is a relative path' do
+        configuration.base_path = 'relative/path'
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/base_path/)
+      end
+
+      it 'should not raise if it is a absolute path' do
+        configuration.base_path = '/absolute/path'
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+    end
+
+    context 'glob_patterns' do
+      it 'should raise an error if it is not an array' do
+        configuration.glob_patterns = ''
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/glob_patterns/)
+      end
+
+      it 'should raise an error if it is empty' do
+        configuration.glob_patterns = []
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/glob_patterns/)
+      end
+
+      it 'should not raise if it is an array' do
+        configuration.glob_patterns = ['*.yml']
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+    end
+
+    context 'locale_pairs' do
+      it 'should raise an error if it is blank' do
+        configuration.locale_pairs = ''
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/locale_pairs/)
+      end
+
+      it 'should raise if it is not an array of pair' do
+        configuration.locale_pairs = [['en']]
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/locale_pairs/)
+      end
+
+      it 'should not raise if it is an array' do
+        configuration.locale_pairs = [['en', 'ja']]
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+    end
+
+    context 'linters' do
+      it 'should raise an error if it is blank' do
+        configuration.linters = ''
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/linters/)
+      end
+
+      it 'should raise if the element contains invalid value' do
+        configuration.linters = [:foo]
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/linters/)
+      end
+
+      it 'should not raise if it is valid' do
+        configuration.linters = [:file_scope]
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+    end
+
+    context 'valid_locales' do
+      it 'should raise an error if it is not an array' do
+        configuration.valid_locales = ''
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/valid_locales/)
+      end
+
+      it 'should raise an error if it is empty' do
+        configuration.valid_locales = []
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/valid_locales/)
+      end
+
+      it 'should not raise if eligible' do
+        configuration.valid_locales = [:en]
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+    end
+
+    context 'split_max_level' do
+      it 'should raise an error if it is not an integer' do
+        configuration.split_max_level = 'foo'
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/split_max_level/)
+      end
+
+      it 'should not raise if it is an integer' do
+        configuration.split_max_level = 123
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+    end
+
+    context 'split_line_threshold' do
+      it 'should raise an error if it is not an integer' do
+        configuration.split_line_threshold = 'foo'
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/split_line_threshold/)
+      end
+
+      it 'should not raise if it is an integer' do
+        configuration.split_line_threshold = 123
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+    end
+  end
+
+  context 'auto config' do
+    describe '#auto_configure!' do
+      it 'should call `load_from_file!` and `update`' do
+        allow(configuration).to receive(:load_from_file!).and_return(true)
+        allow(configuration).to receive(:update).and_return(true)
+
+        expect(configuration).to receive(:load_from_file!).once.ordered
+        expect(configuration).to receive(:update).once.ordered
+
+        configuration.auto_configure!
+      end
+    end
+
+    describe '#load_from_file!' do
+      let(:pwd)            { '/path/to/pwd' }
+      let(:yaml_file_path) { '/path/to/i18n_flow.yml' }
+
+      let(:yaml_file) do
+        FakeFS::FakeFile.new.tap do |f|
+          f.content = <<-YAML
+          glob_patterns:
+            - 'config/locales/**/*.yml'
+          locale_pairs:
+            - ['en', 'ja']
+          valid_locales:
+            - 'ja'
+            - 'en'
+          YAML
+        end
+      end
+
+      before do
+        FakeFS::FileSystem.add(pwd)
+        Dir.chdir(pwd)
+      end
+
+      it 'should raise an error if no file is found' do
+        expect {
+          configuration.send(:load_from_file!)
+        }.to raise_error(I18nFlow::Configuration::NoConfigurationFileFoundError)
+      end
+
+      it 'should set `base_path` to the directory of yaml file' do
+        FakeFS::FileSystem.add(yaml_file_path, yaml_file)
+
+        expect {
+          configuration.send(:load_from_file!)
+        }.not_to raise_error
+
+        expect(configuration.base_path).to eq(Pathname.new(File.dirname(yaml_file_path)))
+      end
+
+      it 'should set other option values from yaml' do
+        FakeFS::FileSystem.add(yaml_file_path, yaml_file)
+
+        expect {
+          configuration.send(:load_from_file!)
+        }.not_to raise_error
+
+        expect(configuration.locale_pairs).to eq([['en', 'ja']])
+        expect(configuration.valid_locales).to eq(['ja', 'en'])
+      end
+
+      it 'should raise an error if there is invalid option in yaml' do
+        FakeFS::FileSystem.add(yaml_file_path, yaml_file)
+        yaml_file.content = <<-YAML
+        foo: true
+        YAML
+
+        expect {
+          configuration.send(:load_from_file!)
+        }.to raise_error(KeyError, /foo/)
+      end
+    end
+  end
+end

data/spec/lib/i18n_flow/repository_spec.rb

@@ -0,0 +1,40 @@
+require 'i18n_flow/repository'
+
+describe I18nFlow::Repository do
+  include_examples :create_repository
+
+  describe '#file_paths' do
+    it 'should return an array of matched file paths' do
+      expect(repository.file_paths).to match_array([
+        '/fixtures/models/user.en.yml',
+        '/fixtures/models/user.ja.yml',
+        '/fixtures/views/profiles/show.en.yml',
+        '/fixtures/views/profiles/show.ja.yml',
+        '/fixtures/views/profiles/show.fr.yml',
+      ])
+    end
+  end
+
+  describe '#asts_by_path' do
+    it 'should return a hash of tree indexed by (relative) file paths' do
+      expect(repository.asts_by_path.keys).to match_array([
+        'models/user.en.yml',
+        'models/user.ja.yml',
+        'views/profiles/show.en.yml',
+        'views/profiles/show.ja.yml',
+        'views/profiles/show.fr.yml',
+      ])
+    end
+  end
+
+  describe '#asts_by_scope' do
+    it 'should return a hash of tree indexed by scopes' do
+      expect(repository.asts_by_scope.keys).to match_array([
+        'models.user',
+        'views.profiles.show',
+      ])
+      expect(repository.asts_by_scope['models.user'].keys).to match_array(['en', 'ja'])
+      expect(repository.asts_by_scope['views.profiles.show'].keys).to match_array(['en', 'ja', 'fr'])
+    end
+  end
+end

data/spec/lib/i18n_flow/splitter/merger_spec.rb

@@ -0,0 +1,149 @@
+require 'i18n_flow/splitter/merger'
+
+describe I18nFlow::Splitter::Merger do
+  let(:merger) { I18nFlow::Splitter::Merger.new([]) }
+
+  describe '#perform_merge!' do
+    it 'should append root chunks' do
+      ast_1 = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar_1: 'bar_1'
+      YAML
+      result = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar_1: 'bar_1'
+      YAML
+
+      allow(merger).to receive(:chunks).and_return([
+        ast_1,
+      ])
+
+      merger.perform_merge!
+
+      expect(merger.to_yaml).to eq(result.to_yaml)
+    end
+
+    it 'should append partial chunks' do
+      ast_1 = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar_1: 'bar_1'
+      YAML
+      result = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar_1: 'bar_1'
+      YAML
+
+      allow(merger).to receive(:chunks).and_return([
+        ast_1['en']['map'],
+      ])
+
+      merger.perform_merge!
+
+      expect(merger.to_yaml).to eq(result.to_yaml)
+    end
+
+    it 'should merge root chunks' do
+      ast_1 = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar: 'bar_1'
+      YAML
+      ast_2 = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_2: 'foo_2'
+          bar: 'bar_2'
+      YAML
+      result = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar: 'bar_2'
+          foo_2: 'foo_2'
+      YAML
+
+      allow(merger).to receive(:chunks).and_return([
+        ast_1,
+        ast_2,
+      ])
+
+      merger.perform_merge!
+
+      expect(merger.to_yaml).to eq(result.to_yaml)
+    end
+
+    it 'should merge partial mapping chunks' do
+      ast_1 = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar: 'bar_1'
+      YAML
+      ast_2 = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_2: 'foo_2'
+          bar: 'bar_2'
+      YAML
+      result = parse_yaml(<<-YAML)
+      en:
+        map:
+          foo_1: 'foo_1'
+          bar: 'bar_2'
+          foo_2: 'foo_2'
+      YAML
+
+      allow(merger).to receive(:chunks).and_return([
+        ast_1['en']['map']['foo_1'],
+        ast_1['en']['map']['bar'],
+        ast_2['en']['map'],
+      ])
+
+      merger.perform_merge!
+
+      expect(merger.to_yaml).to eq(result.to_yaml)
+    end
+
+    it 'should merge partial sequence chunks' do
+      ast_1 = parse_yaml(<<-YAML)
+      en:
+        seq:
+          - 'seq_1_1'
+          - 'seq_1_2'
+      YAML
+      ast_2 = parse_yaml(<<-YAML)
+      en:
+        seq:
+          - 'seq_2_1'
+          - 'seq_2_2'
+      YAML
+      result = parse_yaml(<<-YAML)
+      en:
+        seq:
+          - 'seq_1_1'
+          - 'seq_1_2'
+          - 'seq_2_1'
+          - 'seq_2_2'
+      YAML
+
+      allow(merger).to receive(:chunks).and_return([
+        ast_1['en']['seq'][0],
+        ast_1['en']['seq'][1],
+        ast_2['en']['seq'],
+      ])
+
+      merger.perform_merge!
+
+      expect(merger.to_yaml).to eq(result.to_yaml)
+    end
+  end
+end