rosette-core 1.0.1

data/spec/core/branch_utils_spec.rb

@@ -0,0 +1,110 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+include Rosette::DataStores
+
+describe BranchUtils do
+  let(:repo_name) { 'single_commit' }
+
+  # note: the fixture will only be used for its datastore, the actual contents
+  # of the underlying repository aren't important
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+      repo_config.add_locales(%w(ko-KR ja-JP pt-BR))
+    end
+  end
+
+  let(:datastore) { fixture.config.datastore }
+  let(:commit_log) { InMemoryDataStore::CommitLog }
+  let(:commit_log_locale) { InMemoryDataStore::CommitLogLocale }
+
+  let(:locale_statuses_hash) do
+    {
+      'ko-KR' => { translated_count: 5, percent_translated: 0.5 },
+      'ja-JP' => { translated_count: 9, percent_translated: 0.9 }
+    }.freeze
+  end
+
+  before(:each) do
+    commit_log.create(
+      repo_name: repo_name, phrase_count: 5, commit_id: 'abc123',
+      status: PhraseStatus::FETCHED
+    )
+
+    commit_log_locale.create(
+      commit_id: 'abc123', locale: 'ko-KR', translated_count: 5
+    )
+
+    commit_log_locale.create(
+      commit_id: 'abc123', locale: 'ja-JP', translated_count: 4
+    )
+
+    commit_log.create(
+      repo_name: repo_name, phrase_count: 5, commit_id: 'def456',
+      status: PhraseStatus::PUSHED
+    )
+
+    commit_log_locale.create(
+      commit_id: 'def456', locale: 'ja-JP', translated_count: 5
+    )
+  end
+
+  describe 'derive_status_from' do
+    it 'returns the lowest-ranked status' do
+      status = BranchUtils.derive_status_from(commit_log.entries)
+      expect(status).to eq(PhraseStatus::FETCHED)
+    end
+  end
+
+  describe 'derive_phrase_count_from' do
+    it 'returns a sum of all phrase counts' do
+      count = BranchUtils.derive_phrase_count_from(commit_log.entries)
+      expect(count).to eq(10)
+    end
+  end
+
+  describe 'derive_locale_statuses_from' do
+    it 'returns a hash of locale statuses and translation percentages' do
+      locale_statuses = BranchUtils.derive_locale_statuses_from(
+        commit_log.entries, repo_name, datastore
+      )
+
+      expect(locale_statuses).to eq(locale_statuses_hash)
+    end
+
+    it "doesn't choke when phrase count is zero (possible divide by zero)" do
+      commit_log.entries.each do |entry|
+        entry.phrase_count = 0
+      end
+
+      locale_statuses = BranchUtils.derive_locale_statuses_from(
+        commit_log.entries, repo_name, datastore
+      )
+
+      expect(locale_statuses.keys).to contain_exactly('ko-KR', 'ja-JP')
+
+      locale_statuses.each do |_, status|
+        expect(status[:percent_translated]).to eq(0.0)
+      end
+    end
+  end
+
+  describe 'fill_in_missing_locales' do
+    it 'adds missing locales to the locale statuses hash' do
+      locale_statuses = BranchUtils.fill_in_missing_locales(
+        fixture.config.get_repo(repo_name).locales, locale_statuses_hash
+      )
+
+      expect(locale_statuses).to eq(
+        locale_statuses_hash.merge(
+          'pt-BR' => {
+            translated_count: 0, percent_translated: 0.0
+          }
+        )
+      )
+    end
+  end
+end

data/spec/core/commands/git/commit_command_spec.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe CommitCommand do
+  let(:klass) { CommitCommand }
+  let(:repo_name) { 'single_commit' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+    end
+  end
+
+  let(:command) { CommitCommand.new(fixture.config) }
+  let(:phrase_model) { Rosette::DataStores::InMemoryDataStore::Phrase }
+
+  context 'validation' do
+    it 'requires a valid repo name' do
+      command.set_ref('HEAD')
+      expect(command).to_not be_valid
+    end
+
+    it 'requires a valid ref' do
+      command.set_repo_name('foo')
+      expect(command).to_not be_valid
+    end
+
+    it 'should be valid if both the repo name and ref are set' do
+      command.set_ref('HEAD')
+      command.set_repo_name(repo_name)
+      expect(command).to be_valid
+    end
+  end
+
+  context 'with valid options' do
+    before(:each) do
+      command.set_ref('HEAD')
+      command.set_repo_name(repo_name)
+    end
+
+    describe '#execute' do
+      it 'extracts and stores all phrases' do
+        command.execute
+        expect(phrase_model.entries.map(&:key).sort).to eq([
+          "I'm a little teapot",
+          'The green albatross flitters in the moonlight',
+          'Chatanooga Choo Choo',
+          "Diamonds are a girl's best friend.",
+          'Cash for the merchandise; cash for the fancy goods.',
+          "I'm in Spañish.",
+          ' test string 1',
+          ' test string 2'
+        ].sort)
+      end
+    end
+  end
+end

data/spec/core/commands/git/diff_command_spec.rb

@@ -0,0 +1,263 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe DiffCommand do
+  let(:repo_name) { 'single_commit' }
+
+  let(:fixture) do
+    load_repo_fixture(repo_name) do |config, repo_config|
+      config.use_datastore('in-memory')
+      repo_config.add_extractor('test/test') do |extractor_config|
+        extractor_config.set_conditions do |conditions|
+          conditions.match_file_extension('.txt')
+        end
+      end
+    end
+  end
+
+  let(:diff_command) { DiffCommand.new(fixture.config) }
+
+  context 'validation' do
+    it 'requires a valid repo name' do
+      diff_command.set_head_ref('HEAD')
+      diff_command.set_diff_point_ref('HEAD')
+      expect(diff_command).to_not be_valid
+    end
+
+    it 'requires a head ref' do
+      diff_command.set_repo_name(repo_name)
+      diff_command.set_diff_point_ref('HEAD')
+      expect(diff_command).to_not be_valid
+    end
+
+    it 'requires a diff point ref' do
+      diff_command.set_repo_name(repo_name)
+      diff_command.set_head_ref('HEAD')
+      expect(diff_command).to_not be_valid
+    end
+
+    it 'should be valid if the repo name, head ref, and diff point ref are set' do
+      diff_command.set_repo_name(repo_name)
+      diff_command.set_head_ref('HEAD')
+      diff_command.set_diff_point_ref('HEAD')
+      expect(diff_command).to be_valid
+    end
+  end
+
+  context 'with valid options' do
+    before(:each) do
+      diff_command.set_diff_point_ref(head_ref)
+      diff_command.set_repo_name(repo_name)
+
+      fixture.repo.each_commit_id do |commit_id|
+        commit(fixture.config, repo_name, commit_id)
+      end
+    end
+
+    describe '#execute' do
+      let(:key) { 'Here is a test string' }
+
+      context 'when a phrase is added to HEAD' do
+        before do
+          fixture.repo.create_file('test.txt') do |writer|
+            writer.write(key)
+          end
+
+          fixture.repo.add_all
+          fixture.repo.commit('Commit message')
+
+          commit(fixture.config, repo_name, head_ref)
+          diff_command.set_head_ref(head_ref)
+        end
+
+        it 'returns a diff that contains the added phrase' do
+          added_phrases = diff_command.execute[:added]
+          expect(added_phrases.size).to eq(1)
+          expect(added_phrases.first.phrase.key).to eq(key)
+        end
+      end
+
+      context 'when a phrase is removed from HEAD' do
+        before(:each) do
+          fixture.repo.git('rm -f first_file.txt')
+          fixture.add_all
+          fixture.repo.commit('Remove file.txt')
+
+          commit(fixture.config, repo_name, head_ref)
+          diff_command.set_head_ref(head_ref)
+        end
+
+        it 'returns a diff that contains the removed phrases' do
+          removed_phrases = diff_command.execute[:removed]
+          expect(removed_phrases.size).to eq(2)
+          expect(removed_phrases.map { |diff_entry| diff_entry.phrase.key }).to eq([
+            "I'm a little teapot",
+            "The green albatross flitters in the moonlight"
+          ])
+        end
+      end
+
+      context "when the parent hasn't been processed yet" do
+        let(:repo_name) { 'four_commits' }
+
+        before do
+          parent_commit_id = fixture.repo.git('rev-parse HEAD~3').strip
+          diff_command.set_head_ref(head_ref)
+          diff_command.set_diff_point_ref(parent_commit_id)
+
+          Rosette::DataStores::InMemoryDataStore::CommitLog.entries.reject! do |entry|
+            entry.commit_id == parent_commit_id
+          end
+        end
+
+        it 'raises an error in strict mode' do
+          expect { diff_command.execute }.to raise_error(
+            Rosette::Core::Commands::Errors::UnprocessedCommitError
+          )
+        end
+
+        it 'uses the most recently processed commit in non-strict mode' do
+          show_hash = diff_command.set_strict(false).execute
+          expect(show_hash[:added].map { |entry| entry.phrase.key}.sort).to eq([
+            'bar', 'baz', 'foo', 'goo'
+          ])
+        end
+      end
+
+      context 'with a file that contains metakeys' do
+        let(:file_path) { fixture.working_dir.join('folder/with_metakeys.txt') }
+        let(:phrases) { File.read(file_path).split("\n") }
+
+        context 'when a phrase is modified on HEAD' do
+          let(:new_key) { 'Here is a new string' }
+
+          before do
+            first_phrase = phrases.first.split(':')
+            @meta_key = first_phrase[0]
+            @old_key = first_phrase[1]
+            first_phrase[1] = new_key
+            phrases[0] = first_phrase.join(':')
+
+            File.open(file_path, 'w+') do |f|
+              f.write(phrases.join("\n"))
+            end
+
+            fixture.repo.add_all
+            fixture.repo.commit('Modified a string')
+
+            commit(fixture.config, repo_name, head_ref)
+            diff_command.set_head_ref(head_ref)
+          end
+
+          it 'returns a diff that contains the modified phrase' do
+            modified_phrases = diff_command.execute[:modified]
+            expect(modified_phrases.size).to eq(1)
+            modified_phrase = modified_phrases.first.phrase
+            expect(modified_phrases.first.old_phrase.key).to eq(@old_key)
+            expect(modified_phrase.meta_key).to eq(@meta_key)
+            expect(modified_phrase.key).to eq(new_key)
+          end
+        end
+
+        context 'when a phrase is added to HEAD' do
+          let(:new_meta_key) { 'cool.metakey' }
+          let(:new_key) { 'my new key' }
+
+          before do
+            phrases << new_meta_key + ':' + new_key
+            File.open(file_path, 'w+') do |f|
+              f.write(phrases.join("\n"))
+            end
+
+            fixture.repo.add_all
+            fixture.repo.commit('Added a string')
+
+            commit(fixture.config, repo_name, head_ref)
+            diff_command.set_head_ref(head_ref)
+          end
+
+          it 'returns a diff that contains the added phrase' do
+            added_phrases = diff_command.execute[:added]
+            expect(added_phrases.size).to eq(1)
+            expect(added_phrases.first.phrase.meta_key).to eq(new_meta_key)
+            expect(added_phrases.first.phrase.key).to eq(new_key)
+          end
+        end
+
+        context 'when a phrase is removed from HEAD' do
+          before do
+            first_phrase = phrases.shift.split(':')
+            @meta_key = first_phrase[0]
+            @key = first_phrase[1]
+
+            File.open(file_path, 'w+') do |f|
+              f.write(phrases.join("\n"))
+            end
+
+            fixture.repo.add_all
+            fixture.repo.commit('Removed a string')
+
+            commit(fixture.config, repo_name, head_ref)
+            diff_command.set_head_ref(head_ref)
+          end
+
+          it 'returns a diff that contains the removed phrase' do
+            removed_phrases = diff_command.execute[:removed]
+            expect(removed_phrases.size).to eq(1)
+            expect(removed_phrases.first.phrase.meta_key).to eq(@meta_key)
+            expect(removed_phrases.first.phrase.key).to eq(@key)
+          end
+
+        end
+
+        context "when the given head doesn't contain phrase changes" do
+          let(:file_path) { fixture.working_dir.join('folder/new_file.txt') }
+
+          before do
+            File.open(file_path, 'w+') do |f|
+              f.write('foobarbazboo')
+            end
+
+            fixture.repo.add_all
+            fixture.repo.commit('Added a string')
+            commit(fixture.config, repo_name, head_ref)
+
+            # the .foo file extension isn't processed by the text/text extractor
+            fixture.repo.create_file('test.foo') do |writer|
+              writer.write('foobarbaz')
+            end
+
+            fixture.repo.add_all
+            fixture.repo.commit('Commit message')
+            commit(fixture.config, repo_name, head_ref)
+            diff_command.set_head_ref(head_ref)
+          end
+
+          it 'should show the correct added phrases' do
+            diff = diff_command.execute
+            expect(diff[:added].size).to eq(1)
+            expect(diff[:added].first.phrase.key).to eq('foobarbazboo')
+          end
+        end
+      end
+    end
+  end
+
+  def head_ref
+    fixture.repo.git('rev-parse HEAD').strip
+  end
+
+  def commit(config, repo_name, ref)
+    CommitCommand.new(config)
+      .set_repo_name(repo_name)
+      .set_ref(ref)
+      .execute
+
+    fixture.config.datastore.add_or_update_commit_log(
+      repo_name, ref, nil
+    )
+  end
+end

data/spec/core/commands/git/fetch_command_spec.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core::Commands
+
+describe FetchCommand do
+  let(:source_repo) { TmpRepo.new }
+  let(:dest_repo) { TmpRepo.new }
+  let(:repo_name) { 'my_repo' }
+
+  let(:configuration) do
+    Rosette.build_config do |config|
+      config.add_repo(repo_name) do |repo_config|
+        repo_config.set_path(dest_repo.working_dir.join('.git').to_s)
+      end
+    end
+  end
+
+  let(:command) do
+    Rosette::Core::Commands::FetchCommand.new(configuration)
+  end
+
+  context 'validation' do
+    it 'requires a valid repo name' do
+      expect(command).to_not be_valid
+    end
+
+    it 'should be valid if repo name is set' do
+      command.set_repo_name(repo_name)
+      expect(command).to be_valid
+    end
+  end
+
+  context '#execute' do
+    before do
+      command.set_repo_name(repo_name)
+    end
+
+    it 'fetches new commits from origin' do
+      source_repo.create_file('foo.txt') { |f| f.write('foo') }
+      source_repo.add_all
+      source_repo.commit('Initial commit')
+
+      source_repo.create_branch('new_branch')
+      source_repo.create_file('bar.txt') { |f| f.write('bar') }
+      source_repo.add_all
+      source_repo.commit('Second commit')
+      source_repo.checkout('master')
+
+      expect(dest_repo.git('branch -a').strip.split("\n")).to be_empty
+
+      dest_repo.git("remote add origin #{source_repo.working_dir}")
+      command.execute
+
+      expect(dest_repo.git('branch -a').split("\n").map(&:strip)).to(
+        eq(['remotes/origin/master', 'remotes/origin/new_branch'])
+      )
+    end
+  end
+end