rosette-core 1.0.1

data/spec/core/resolvers/extractor_id_spec.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe ExtractorId do
+  module ExtractorsNoNaming
+    module Foo
+      class Bar; end
+    end
+  end
+
+  module ExtractorsOneLevel
+    module Foo
+      class BarExtractor; end
+    end
+  end
+
+  module ExtractorsTwoLevels
+    module FooExtractor
+      class BarExtractor; end
+    end
+  end
+
+  let(:id) { ExtractorId }
+
+  describe '#resolve' do
+    it 'resolves constants with no modified naming' do
+      expect(id.resolve('foo/bar', ExtractorsNoNaming)).to(
+        be(ExtractorsNoNaming::Foo::Bar)
+      )
+    end
+
+    it 'resolves constants with one level of naming' do
+      expect(id.resolve('foo/bar', ExtractorsOneLevel)).to(
+        be(ExtractorsOneLevel::Foo::BarExtractor)
+      )
+    end
+
+    it 'resolves constants with two levels of naming' do
+      expect(id.resolve('foo/bar', ExtractorsTwoLevels)).to(
+        be(ExtractorsTwoLevels::FooExtractor::BarExtractor)
+      )
+    end
+  end
+end

data/spec/core/resolvers/integration_id_spec.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe IntegrationId do
+  module IntegrationsNoNaming
+    module Foo
+      class Bar; end
+    end
+  end
+
+  module IntegrationsOneLevel
+    module Foo
+      class BarIntegration; end
+    end
+  end
+
+  module IntegrationsTwoLevels
+    module FooIntegration
+      class BarIntegration; end
+    end
+  end
+
+  let(:id) { IntegrationId }
+
+  describe '#resolve' do
+    it 'resolves constants with no modified naming' do
+      expect(id.resolve('foo/bar', IntegrationsNoNaming)).to(
+        be(IntegrationsNoNaming::Foo::Bar)
+      )
+    end
+
+    it 'resolves constants with one level of naming' do
+      expect(id.resolve('foo/bar', IntegrationsOneLevel)).to(
+        be(IntegrationsOneLevel::Foo::BarIntegration)
+      )
+    end
+
+    it 'resolves constants with two levels of naming' do
+      expect(id.resolve('foo/bar', IntegrationsTwoLevels)).to(
+        be(IntegrationsTwoLevels::FooIntegration::BarIntegration)
+      )
+    end
+  end
+end

data/spec/core/resolvers/preprocessor_id_spec.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe PreprocessorId do
+  module PreprocessorsNoNaming
+    module Foo
+      class Bar; end
+    end
+  end
+
+  module PreprocessorsOneLevel
+    module Foo
+      class BarPreprocessor; end
+    end
+  end
+
+  module PreprocessorsTwoLevels
+    module FooPreprocessor
+      class BarPreprocessor; end
+    end
+  end
+
+  let(:id) { PreprocessorId }
+
+  describe '#resolve' do
+    it 'resolves constants with no modified naming' do
+      expect(id.resolve('foo/bar', PreprocessorsNoNaming)).to(
+        be(PreprocessorsNoNaming::Foo::Bar)
+      )
+    end
+
+    it 'resolves constants with one level of naming' do
+      expect(id.resolve('foo/bar', PreprocessorsOneLevel)).to(
+        be(PreprocessorsOneLevel::Foo::BarPreprocessor)
+      )
+    end
+
+    it 'resolves constants with two levels of naming' do
+      expect(id.resolve('foo/bar', PreprocessorsTwoLevels)).to(
+        be(PreprocessorsTwoLevels::FooPreprocessor::BarPreprocessor)
+      )
+    end
+  end
+end

data/spec/core/resolvers/serializer_id_spec.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe SerializerId do
+  module SerializersNoNaming
+    module Foo
+      class Bar; end
+    end
+  end
+
+  module SerializersOneLevel
+    module Foo
+      class BarSerializer; end
+    end
+  end
+
+  module SerializersTwoLevels
+    module FooSerializer
+      class BarSerializer; end
+    end
+  end
+
+  let(:id) { SerializerId }
+
+  describe '#resolve' do
+    it 'resolves constants with no modified naming' do
+      expect(id.resolve('foo/bar', SerializersNoNaming)).to(
+        be(SerializersNoNaming::Foo::Bar)
+      )
+    end
+
+    it 'resolves constants with one level of naming' do
+      expect(id.resolve('foo/bar', SerializersOneLevel)).to(
+        be(SerializersOneLevel::Foo::BarSerializer)
+      )
+    end
+
+    it 'resolves constants with two levels of naming' do
+      expect(id.resolve('foo/bar', SerializersTwoLevels)).to(
+        be(SerializersTwoLevels::FooSerializer::BarSerializer)
+      )
+    end
+  end
+end

data/spec/core/snapshots/snapshot_factory_spec.rb

@@ -0,0 +1,145 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe SnapshotFactory do
+  let(:factory_class) { SnapshotFactory }
+  let(:repo_name) { 'fake_app' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:commits) do
+    fixture.git('rev-list --all').split("\n").reverse
+  end
+
+  let(:rosette_config) do
+    Rosette.build_config do |config|
+      config.add_repo(repo_name) do |repo_config|
+        repo_config.set_path(fixture.working_dir.join('.git').to_s)
+      end
+    end
+  end
+
+  let(:repo_config) do
+    rosette_config.get_repo(repo_name)
+  end
+
+  describe '#take_snapshot' do
+    it 'returns the correct snapshot for the first commit' do
+      factory = factory_class.new
+        .set_repo_config(repo_config)
+        .set_start_commit_id(commits.first)
+
+      factory.take_snapshot.tap do |snapshot|
+        expect(snapshot).to eq(
+          'app/controllers/product_controller.txt' => commits.first,
+          'app/models/product.txt' => commits.first,
+          'app/views/product/edit.txt' => commits.first,
+          'app/controllers/file.other' => commits.first
+        )
+      end
+    end
+
+    it 'raises an error if passed a non-staged progress reporter' do
+      reporter = ::ProgressReporters::ProgressReporter.new
+
+      factory = factory_class.new
+        .set_repo_config(repo_config)
+        .set_start_commit_id(commits.first)
+
+      expect(lambda { factory.take_snapshot(reporter) }).to(
+        raise_error(ArgumentError)
+      )
+    end
+
+    context 'with a factory pointed at the last commit' do
+      let(:factory) do
+        factory_class.new
+          .set_repo_config(repo_config)
+          .set_start_commit_id(commits.last)
+      end
+
+      it 'returns the correct snapshot for the second commit' do
+        factory.take_snapshot.tap do |snapshot|
+          expect(snapshot).to eq(
+            'app/controllers/product_controller.txt' => commits.first,
+            'app/models/product.txt' => commits.first,
+            'app/views/product/edit.txt' => commits.first,
+            'app/controllers/order_controller.txt' => commits.last,
+            'app/models/order.txt' => commits.last,
+            'app/models/line_item.txt' => commits.last,
+            'app/views/order/index.txt' => commits.last,
+            'app/controllers/file.other' => commits.first,
+            'app/models/another_file.other' => commits.last
+          )
+        end
+      end
+
+      it 'only includes files with matching file extensions when asked' do
+        repo_config.add_extractor('test/test') do |extractor_config|
+          extractor_config.set_conditions do |conditions|
+            conditions.match_file_extension('.other')
+          end
+        end
+
+        factory.take_snapshot.tap do |snapshot|
+          expect(snapshot).to eq(
+            'app/controllers/file.other' => commits.first,
+            'app/models/another_file.other' => commits.last
+          )
+        end
+      end
+
+      it 'only includes files with matching paths when asked' do
+        repo_config.add_extractor('test/test') do |extractor_config|
+          extractor_config.set_conditions do |conditions|
+            conditions.match_path('app/controllers')
+          end
+        end
+
+        factory.take_snapshot.tap do |snapshot|
+          expect(snapshot).to eq(
+            'app/controllers/product_controller.txt' => commits.first,
+            'app/controllers/order_controller.txt' => commits.last,
+            'app/controllers/file.other' => commits.first
+          )
+        end
+      end
+
+      it 'supports combining multiple filters with a logical OR' do
+        repo_config.add_extractor('test/test') do |extractor_config|
+          extractor_config.set_conditions do |conditions|
+            conditions.match_path('app/controllers').or(
+              conditions.match_file_extension('.other')
+            )
+          end
+        end
+
+        factory.take_snapshot.tap do |snapshot|
+          expect(snapshot).to eq(
+            'app/controllers/product_controller.txt' => commits.first,
+            'app/controllers/order_controller.txt' => commits.last,
+            'app/controllers/file.other' => commits.first,
+            'app/models/another_file.other' => commits.last
+          )
+        end
+      end
+
+      it 'supports combining multiple filters with a logical AND' do
+        repo_config.add_extractor('test/test') do |extractor_config|
+          extractor_config.set_conditions do |conditions|
+            conditions.match_path('app/controllers').and(
+              conditions.match_file_extension('.other')
+            )
+          end
+        end
+
+        factory.take_snapshot.tap do |snapshot|
+          expect(snapshot).to eq(
+            'app/controllers/file.other' => commits.first
+          )
+        end
+      end
+    end
+  end
+end

data/spec/core/string_utils_spec.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe StringUtils do
+  let(:utils) { Rosette::Core::StringUtils }
+
+  describe '#camelize' do
+    it 'treats underscores as capitalization boundaries' do
+      expect(utils.camelize('foo_bar')).to eq('FooBar')
+    end
+
+    it 'treats dashes as capitalization boundaries' do
+      expect(utils.camelize('foo-bar')).to eq('FooBar')
+    end
+  end
+end

data/spec/core/translation_status_spec.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe TranslationStatus do
+  let(:phrase_count) { 10 }
+  let(:german) { 'de-DE' }
+  let(:korean) { 'ko-KR' }
+  let(:status) { TranslationStatus.new(phrase_count) }
+
+  describe '#add_locale_count' do
+    it 'adds a locale and corresponding count' do
+      status.add_locale_count(german, 5)
+      expect(status.locale_counts[german]).to eq(5)
+    end
+  end
+
+  describe '#locale_count' do
+    it 'retrieves the translation count for the given locale' do
+      status.add_locale_count(german, 5)
+      expect(status.locale_count(german)).to eq(5)
+    end
+  end
+
+  describe '#locales' do
+    it 'returns a list of all added locales' do
+      status.add_locale_count(german, 1)
+      status.add_locale_count(korean, 2)
+      expect(status.locales.sort).to eq([german, korean].sort)
+    end
+  end
+
+  describe '#fully_translated_in?' do
+    it 'returns true if the locale is fully translated' do
+      status.add_locale_count(german, phrase_count)
+      expect(status).to be_fully_translated_in(german)
+    end
+
+    it 'returns true if the locale contains more translations than phrases' do
+      status.add_locale_count(german, phrase_count + 1)
+      expect(status).to be_fully_translated_in(german)
+    end
+
+    it 'returns false if the locale is not fully translated' do
+      status.add_locale_count(german, phrase_count - 1)
+      expect(status).to_not be_fully_translated_in(german)
+    end
+  end
+
+  describe '#fully_translated?' do
+    it 'returns true if all locales are fully translated' do
+      status.add_locale_count(german, phrase_count)
+      status.add_locale_count(korean, phrase_count)
+      expect(status).to be_fully_translated
+    end
+
+    it 'returns false if at least one locale is not fully translated' do
+      status.add_locale_count(german, phrase_count)
+      status.add_locale_count(korean, phrase_count - 1)
+      expect(status).to_not be_fully_translated
+    end
+  end
+
+  describe '#percent_translated' do
+    it 'calculates the percent translated for the given locale' do
+      status.add_locale_count(german, phrase_count / 2)
+      expect(status.percent_translated(german)).to eq(0.5)
+    end
+
+    it 'returns 1.0 if translations outnumber phrases' do
+      status.add_locale_count(german, phrase_count + 1)
+      expect(status.percent_translated(german)).to eq(1.0)
+    end
+
+    context 'with an odd number of phrases' do
+      let(:phrase_count) { 7 }
+
+      it 'defaults to a precision of two decimal places' do
+        status.add_locale_count(german, 3)
+        expect(status.percent_translated(german)).to eq(0.43)
+      end
+
+      it 'rounds to the given number of decimal places' do
+        status.add_locale_count(german, 3)
+        expect(status.percent_translated(german, 3)).to eq(0.429)
+      end
+    end
+  end
+end