rosette-core 1.0.1

data/spec/core/extractor/commit_processor_spec.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe CommitProcessor do
+  let(:repo_name) { 'single_commit' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:error_reporter) { BufferedErrorReporter.new }
+
+  let(:processor) do
+    CommitProcessor.new(fixture.config, error_reporter)
+  end
+
+  describe '#process_each_phrase' do
+    it 'extracts each phrase in the commit and returns an enum' do
+      fixture.each_commit do |fixture_commit|
+        processor.process_each_phrase(repo_name, fixture_commit.sha).tap do |phrase_enum|
+          expect(phrase_enum).to be_a(Enumerator)
+
+          phrase_enum.to_a.tap do |phrases|
+            expect(phrases.size).to eq(8)
+            phrases.each { |phrase| fixture_commit.remove(phrase) }
+          end
+        end
+
+        expect(fixture_commit).to_not have_more_phrases
+        expect(error_reporter.errors).to be_empty
+      end
+    end
+
+    it 'reports syntax errors if they occur' do
+      allow_any_instance_of(Rosette::Extractors::Test::TestExtractor).to(
+        receive(:each_function_call)
+        .with(anything)
+        .and_raise(
+          Rosette::Core::SyntaxError.new(
+            'nope', StandardError.new('error'), :txt
+          )
+        )
+      )
+
+      fixture.each_commit do |fixture_commit|
+        processor.process_each_phrase(repo_name, fixture_commit.sha).to_a
+
+        error_reporter.errors.tap do |errors|
+          expect(errors.size).to eq(3)
+
+          errors.each do |error|
+            expect(error[:error].original_exception).to be_a(StandardError)
+            expect(error[:error].message).to eq(
+              "nope (txt): error (txt) in #{error[:error].file} at #{fixture_commit.sha}"
+            )
+            expect(error[:error].language).to eq(:txt)
+            expect(error[:error].commit_id).to eq(fixture_commit.sha)
+          end
+
+          expect(errors.map { |e| e[:error].file }.sort).to eq([
+            'first_file.txt',
+            'folder/second_file.txt',
+            'folder/with_metakeys.txt'
+          ].sort)
+        end
+      end
+    end
+  end
+end

data/spec/core/extractor/extractor_config_spec.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe ExtractorConfig do
+  let(:extractor_class) { Rosette::Extractors::Test::TestExtractor }
+  let(:extractor_id) { 'test/test' }
+
+  it 'instantiates the extractor given' do
+    ExtractorConfig.new(extractor_id, extractor_class).tap do |config|
+      expect(config.extractor).to be_instance_of(extractor_class)
+      expect(config.extractor_id).to eq(extractor_id)
+    end
+  end
+
+  it 'sets a default encoding' do
+    ExtractorConfig.new(extractor_id, extractor_class).tap do |config|
+      expect(config.encoding).to eq(Rosette::Core::DEFAULT_ENCODING)
+    end
+  end
+
+  describe '#set_encoding' do
+    let(:config) { ExtractorConfig.new(extractor_id, extractor_class) }
+
+    it 'sets the encoding on the instance' do
+      config.set_encoding(Encoding::UTF_16BE).tap do |config_with_encoding|
+        expect(config_with_encoding).to be(config)
+        expect(config_with_encoding.encoding).to eq(Encoding::UTF_16BE)
+      end
+    end
+  end
+
+  describe '#matches?' do
+    let(:config) { ExtractorConfig.new(extractor_id, extractor_class) }
+
+    it 'delegates #matches? to root' do
+      config.set_conditions do |cond|
+        cond.match_regex(/values-(ja|de)/)
+      end
+
+      expect(config.matches?('MyProject/stuff/values-ja')).to be_truthy
+      expect(config.matches?('MyProject/stuff/values-pt')).to be_falsey
+    end
+  end
+end

data/spec/core/extractor/extractor_spec.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe Extractor do
+  let(:extractor) do
+    Rosette::Extractors::Test::TestExtractor.new
+  end
+
+  describe '#extract_each_from' do
+    it 'extracts each line and line number from the text file and yields the results' do
+      extractor.extract_each_from("foo\nbar").tap do |extract_enum|
+        expect(extract_enum).to be_a(Enumerator)
+        extract_enum.to_a.tap do |phrases|
+          expect(phrases.size).to eq(2)
+          expect(phrases.all? { |phrase| phrase.first.is_a?(Phrase) }).to be(true)
+          expect(phrases.all? { |phrase| phrase.last.is_a?(Fixnum) }).to be(true)  # line numbers
+          expect(phrases.first.first.key).to eq('foo')
+          expect(phrases.last.first.key).to eq('bar')
+        end
+      end
+    end
+  end
+end

data/spec/core/extractor/locale_spec.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe Locale do
+  let(:locale) { Locale }
+
+  describe 'self.parse' do
+    it 'returns a locale object' do
+      expect(locale.parse('es_MX')).to be_a(Locale)
+    end
+
+    it "raises an error if the locale format isn't recognized" do
+      expect(lambda { locale.parse('es_MX', :foo) }).to(
+        raise_error(ArgumentError)
+      )
+    end
+  end
+end
+
+describe Bcp47Locale do
+  let(:locale) { Bcp47Locale }
+
+  describe 'self.parse' do
+    it 'returns a locale object with the correct language and territory' do
+      locale.parse('es_MX').tap do |locale|
+        expect(locale).to be_a(Bcp47Locale)
+        expect(locale.language).to eq('es')
+        expect(locale.territory).to eq('MX')
+      end
+    end
+
+    it 'returns a locale object with a blank territory when not specified' do
+      locale.parse('es').tap do |locale|
+        expect(locale).to be_a(Bcp47Locale)
+        expect(locale.language).to eq('es')
+        expect(locale.territory).to be_nil
+      end
+    end
+
+    it 'raises an error if the locale is invalid' do
+      expect(lambda { locale.parse('es_MXFGOA') }).to(
+        raise_error(InvalidLocaleError)
+      )
+    end
+  end
+
+  describe 'self.valid?' do
+    it 'ensures locale contains a 2 to 4 char language code' do
+      expect(locale.valid?('es')).to be_truthy
+      expect(locale.valid?('foobar')).to be_falsy
+    end
+
+    it 'validates the optional 2 to 5 character territory code' do
+      expect(locale.valid?('es_MX')).to be_truthy
+      expect(locale.valid?('es_MXFGOA')).to be_falsy
+    end
+
+    it 'allows both dashes and underscores to be used' do
+      expect(locale.valid?('es_MX')).to be_truthy
+      expect(locale.valid?('es-MX')).to be_truthy
+    end
+  end
+
+  describe '#code' do
+    it 'includes the language and territory' do
+      loc = locale.new('es', 'MX')
+      expect(loc.code).to eq('es-MX')
+    end
+
+    it "doesn't include the territory if nil" do
+      loc = locale.new('es')
+      expect(loc.code).to eq('es')
+    end
+  end
+
+  describe '#eql?' do
+    it 'equates two locales with the same language and territory' do
+      expect(locale.new('es', 'MX')).to eq(locale.new('es', 'mx'))
+    end
+
+    it 'does not equate two locales with different territories' do
+      expect(locale.new('es', 'MX')).to_not eq(locale.new('es', 'PE'))
+    end
+
+    it 'does not equate two locales with different languages' do
+      expect(locale.new('fr', 'CA')).to_not eq(locale.new('en', 'CA'))
+    end
+  end
+end

data/spec/core/extractor/phrase/phrase_index_policy_spec.rb

@@ -0,0 +1,116 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe PhraseIndexPolicy do
+  class PhraseIndexPolicyTester
+    include PhraseIndexPolicy
+
+    attr_reader :key, :meta_key
+
+    def initialize
+      @key, @meta_key = nil, nil
+    end
+
+    def set_key(key)
+      @key = key
+    end
+
+    def set_meta_key(meta_key)
+      @meta_key = meta_key
+    end
+  end
+
+  let(:policy) { PhraseIndexPolicyTester }
+  let(:policy_instance) { policy.new }
+
+  describe '#index_key and #index_value' do
+    it 'returns :meta_key if the key is nil' do
+      policy_instance.set_meta_key('meta key')
+      expect(policy_instance.index_key).to eq(:meta_key)
+      expect(policy_instance.index_value).to eq('meta key')
+    end
+
+    it 'returns :key even if the key is emtpy (and the meta key is nil)' do
+      policy_instance.set_key('')
+      expect(policy_instance.index_key).to eq(:key)
+      expect(policy_instance.index_value).to eq('')
+    end
+
+    it 'returns :key if the meta key is nil' do
+      policy_instance.set_key('key')
+      expect(policy_instance.index_key).to eq(:key)
+      expect(policy_instance.index_value).to eq('key')
+    end
+
+    it 'returns :key if the meta key is empty' do
+      policy_instance.set_meta_key('')
+      expect(policy_instance.index_key).to eq(:key)
+      expect(policy_instance.index_value).to eq('')
+    end
+
+    it 'returns :meta_key if both key and meta key are not nil (or empty)' do
+      policy_instance.set_key('key')
+      policy_instance.set_meta_key('meta key')
+      expect(policy_instance.index_key).to eq(:meta_key)
+      expect(policy_instance.index_value).to eq('meta key')
+    end
+
+    it 'returns :key if both key and meta key are empty' do
+      policy_instance.set_key('')
+      policy_instance.set_meta_key('')
+      expect(policy_instance.index_key).to eq(:key)
+      expect(policy_instance.index_value).to eq('')
+    end
+
+    it 'returns :key if both key and meta key are nil' do
+      expect(policy_instance.index_key).to eq(:key)
+      expect(policy_instance.index_value).to eq('')
+    end
+
+    it 'converts nils to empty strings' do
+      expect(policy_instance.key).to be_nil
+      expect(policy_instance.index_key).to eq(:key)
+      expect(policy_instance.index_value).to eq('')
+    end
+  end
+
+  describe 'self.index_key and self.index_value' do
+    it 'returns :meta_key if the key is nil' do
+      expect(policy.index_key(nil, 'meta key')).to eq(:meta_key)
+      expect(policy.index_value(nil, 'meta key')).to eq('meta key')
+    end
+
+    it 'returns :key even if the key is emtpy (and the meta key is nil)' do
+      expect(policy.index_key('', nil)).to eq(:key)
+      expect(policy.index_value('', nil)).to eq('')
+    end
+
+    it 'returns :key if the meta key is nil' do
+      expect(policy.index_key('key', nil)).to eq(:key)
+      expect(policy.index_value('key', nil)).to eq('key')
+    end
+
+    it 'returns :key if the meta key is empty' do
+      expect(policy.index_key(nil, '')).to eq(:key)
+      expect(policy.index_value(nil, '')).to eq('')
+    end
+
+    it 'returns :meta_key if both key and meta key are not nil (or empty)' do
+      expect(policy.index_key('key', 'meta key')).to eq(:meta_key)
+      expect(policy.index_value('key', 'meta key')).to eq('meta key')
+    end
+
+    it 'returns :key if both key and meta key are empty' do
+      expect(policy.index_key('', '')).to eq(:key)
+      expect(policy.index_value('', '')).to eq('')
+    end
+
+    it 'returns :key if both key and meta key are nil (and converts nils to strings)' do
+      expect(policy.index_key(nil, nil)).to eq(:key)
+      expect(policy.index_value(nil, nil)).to eq('')
+    end
+  end
+end

data/spec/core/extractor/phrase/phrase_to_hash_spec.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe PhraseToHash do
+  describe '#to_h' do
+    it 'returns a hash of the appropriate attributes' do
+      TestPhrase.new('key', 'meta key', 'file', 'commit id') do |t|
+        expect(t.to_h).to eq({
+          key: 'key', meta_key: 'meta key',
+          file: 'file', commit_id: 'commit id'
+        })
+      end
+    end
+  end
+end

data/spec/core/extractor/repo_config_spec.rb

@@ -0,0 +1,147 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe RepoConfig do
+  let(:rosette_config) { nil }
+  let(:config) { RepoConfig.new('repo-name', rosette_config) }
+
+  describe '#set_path' do
+    it 'sets the repo path and instantiates a repo object inside the config' do
+      repo = TmpRepo.new
+      config.set_path(repo.working_dir.join('.git').to_s)
+      expect(config.repo).to be_a(Repo)
+      expect(config.repo.path).to eq(repo.working_dir.to_s)
+      expect(config.path).to eq(repo.working_dir.to_s)
+      repo.unlink
+    end
+  end
+
+  describe '#add_extractor' do
+    it 'creates an extractor config, yields it, and adds it to the list of extractor configs' do
+      expect(config.extractor_configs.size).to eq(0)
+
+      config.add_extractor('test/test') do |extractor_config|
+        expect(extractor_config).to be_a(ExtractorConfig)
+      end
+
+      expect(config.extractor_configs.size).to eq(1)
+
+      config.extractor_configs.first.tap do |config|
+        expect(config.extractor).to be_a(Rosette::Extractors::Test::TestExtractor)
+      end
+    end
+  end
+
+  describe '#add_serializer' do
+    it 'creates a serializer config and adds it to the list of serializer configs' do
+      expect(config.serializer_configs.size).to eq(0)
+      config.add_serializer('my_serializer', format: 'test/test')
+      expect(config.serializer_configs.size).to eq(1)
+
+      config.serializer_configs.first.tap do |serializer_config|
+        expect(serializer_config.klass).to eq(Rosette::Serializers::Test::TestSerializer)
+        expect(serializer_config.serializer_id).to eq('test/test')
+      end
+    end
+  end
+
+  describe '#add_locale' do
+    it 'parses the locale and adds it to the list of locales' do
+      expect(config.locales.size).to eq(0)
+      config.add_locale('es-MX')
+      expect(config.locales.size).to eq(1)
+
+      config.locales.first.tap do |locale|
+        expect(locale.language).to eq('es')
+        expect(locale.territory).to eq('MX')
+      end
+    end
+  end
+
+  describe '#add_locales' do
+    it 'parses all the locales and adds them to the list of locales' do
+      expect(config.locales.size).to eq(0)
+      config.add_locales(['es-MX', 'fr-CA'])
+      expect(config.locales.size).to eq(2)
+
+      config.locales.first.tap do |locale|
+        expect(locale.language).to eq('es')
+        expect(locale.territory).to eq('MX')
+      end
+
+      config.locales.last.tap do |locale|
+        expect(locale.language).to eq('fr')
+        expect(locale.territory).to eq('CA')
+      end
+    end
+  end
+
+  describe '#get_extractor_configs' do
+    before(:each) do
+      config.add_extractor('test/test') do |extractor_config|
+        extractor_config.set_conditions do |conditions|
+          conditions.match_file_extension('.js')
+        end
+      end
+    end
+
+    it 'returns all the extractor configs that match the given file extension' do
+      matching_configs = config.get_extractor_configs('foo/bar/baz.js')
+      expect(matching_configs.size).to eq(1)
+
+      matching_configs.first.tap do |extractor_config|
+        expect(extractor_config.extractor).to(
+          be_a(Rosette::Extractors::Test::TestExtractor)
+        )
+      end
+    end
+
+    it 'returns nil if no extractor can be found' do
+      expect(config.get_extractor_configs('foo/bar/baz.rb')).to be_empty
+    end
+  end
+
+  describe '#get_serializer_config' do
+    it 'returns the serializer config that matches the given id' do
+      config.add_serializer('my_serializer', format: 'test/test')
+      expect(config.get_serializer_config('test/test')).to(
+        be(config.serializer_configs.first)
+      )
+    end
+  end
+
+  describe '#get_locale' do
+    it 'returns the locale object for the given code' do
+      config.add_locales(['es-MX', 'fr-CA', 'zh-CN'])
+      config.get_locale('fr-CA').tap do |locale|
+        expect(locale).to be_a(Locale)
+        expect(locale.language).to eq('fr')
+        expect(locale.territory).to eq('CA')
+      end
+    end
+  end
+
+  describe '#use_tms' do
+    it 'looks the tms constant up by string' do
+      config.use_tms('test')
+      expect(config.tms).to be_a(Rosette::Tms::TestTms::Repository)
+    end
+
+    it 'accepts a constant instead of a string' do
+      config.use_tms(Rosette::Tms::TestTms)
+      expect(config.tms).to be_a(Rosette::Tms::TestTms::Repository)
+    end
+
+    it 'yields a configuration object' do
+      config.use_tms('test') do |configurator|
+        expect(configurator).to be_a(Rosette::Tms::TestTms::Configurator)
+        configurator.set_test_value('foobar')
+      end
+
+      expect(config.tms.configurator.test_value).to eq('foobar')
+    end
+  end
+end