txgh 1.0.0

data/spec/category_support_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+include Txgh
+
+describe CategorySupport do
+  describe '.deserialize_categories' do
+    it 'converts an array of categories into a hash' do
+      categories = %w(captain:janeway commander:chakotay)
+      result = CategorySupport.deserialize_categories(categories)
+      expect(result).to eq('captain' => 'janeway', 'commander' => 'chakotay')
+    end
+
+    it 'converts an array of space-separated categories' do
+      categories = ['captain:janeway commander:chakotay']
+      result = CategorySupport.deserialize_categories(categories)
+      expect(result).to eq('captain' => 'janeway', 'commander' => 'chakotay')
+    end
+  end
+
+  describe '.serialize_categories' do
+    it 'converts a hash of categories into an array' do
+      categories = { 'captain' => 'janeway', 'commander' => 'chakotay' }
+      result = CategorySupport.serialize_categories(categories)
+      expect(result.sort).to eq(['captain:janeway', 'commander:chakotay'])
+    end
+  end
+
+  describe '.escape_category' do
+    it 'replaces spaces in category values' do
+      expect(CategorySupport.escape_category('Katherine Janeway')).to(
+        eq('Katherine_Janeway')
+      )
+    end
+  end
+
+  describe '.join_categories' do
+    it 'joins an array of categories by spaces' do
+      expect(CategorySupport.join_categories(%w(foo:bar baz:boo))).to(
+        eq('foo:bar baz:boo')
+      )
+    end
+  end
+end

data/spec/config/config_pair_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+
+include Txgh::Config
+
+describe ConfigPair do
+  include StandardTxghSetup
+
+  let(:config) do
+    ConfigPair.new(project_config, repo_config)
+  end
+
+  describe '#github_repo' do
+    it 'instantiates a github repo with the right config' do
+      repo = config.github_repo
+      expect(repo).to be_a(GithubRepo)
+      expect(repo.name).to eq(repo_name)
+      expect(repo.branch).to eq(branch)
+    end
+  end
+
+  describe '#transifex_project' do
+    it 'instantiates a transifex project with the right config' do
+      project = config.transifex_project
+      expect(project).to be_a(TransifexProject)
+      expect(project.name).to eq(project_name)
+      expect(tx_config.resources.first.resource_slug).to eq(resource_slug)
+    end
+  end
+
+  describe '#transifex_api' do
+    it 'instantiates an API instance' do
+      api = config.transifex_api
+      expect(api).to be_a(TransifexApi)
+      expect(api.connection.headers).to include('Authorization')
+    end
+  end
+
+  describe '#github_api' do
+    it 'instantiates an API instance' do
+      api = config.github_api
+      expect(api).to be_a(GithubApi)
+      expect(api.client.login).to eq(repo_config['api_username'])
+      expect(api.client.access_token).to eq(repo_config['api_token'])
+    end
+  end
+end

data/spec/config/key_manager_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+
+include Txgh
+include Txgh::Config
+
+describe KeyManager do
+  include StandardTxghSetup
+
+  describe '.config_from_project' do
+    it 'creates a config object' do
+      config = KeyManager.config_from_project(project_name)
+      expect(config).to be_a(Txgh::Config)
+    end
+
+    it 'creates a config object that contains both project and repo configs' do
+      config = KeyManager.config_from_project(project_name)
+      expect(config.project_config).to eq(project_config)
+      expect(config.repo_config).to eq(repo_config)
+    end
+  end
+
+  describe '.config_from_repo' do
+    it 'creates a config object' do
+      config = KeyManager.config_from_repo(repo_name)
+      expect(config).to be_a(Txgh::Config)
+    end
+
+    it 'creates a config object that contains both project and repo configs' do
+      config = KeyManager.config_from_repo(repo_name)
+      expect(config.project_config).to eq(project_config)
+      expect(config.repo_config).to eq(repo_config)
+    end
+  end
+
+  describe '.config_from' do
+    it 'creates a config object' do
+      config = KeyManager.config_from(project_name, repo_name)
+      expect(config).to be_a(Txgh::Config)
+    end
+
+    it 'creates a config object that contains both project and repo configs' do
+      config = KeyManager.config_from(project_name, repo_name)
+      expect(config.project_config).to eq(project_config)
+      expect(config.repo_config).to eq(repo_config)
+    end
+  end
+end

data/spec/config/provider_instance_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'helpers/test_provider'
+
+include Txgh
+include Txgh::Config
+
+describe ProviderInstance do
+  let(:provider) { TestProvider }
+  let(:payload) { :fake_payload }
+  let(:parser) { :fake_parser }
+  let(:options) { :fake_options }
+  let(:instance) { ProviderInstance.new(provider, parser) }
+
+  describe '#supports?' do
+    it 'returns true if the scheme matches' do
+      expect(instance.supports?('test')).to eq(true)
+    end
+
+    it "returns false if the scheme doesn't match" do
+      expect(instance.supports?('foo')).to eq(false)
+    end
+  end
+
+  describe '#load' do
+    it "calls the provider's load method passing the parser and options" do
+      expect(provider).to receive(:load).with(payload, parser, options)
+      instance.load(payload, options)
+    end
+  end
+end

data/spec/config/provider_support_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'helpers/test_provider'
+
+include Txgh
+include Txgh::Config
+
+describe ProviderSupport do
+  let(:klass) do
+    Class.new { extend ProviderSupport }
+  end
+
+  let(:provider) { TestProvider }
+
+  describe '#register_provider' do
+    it 'adds an instance to the provider list' do
+      expect { klass.register_provider(:fake_provider, :fake_parser) }.to(
+        change { klass.providers.size }.by(1)
+      )
+
+      instance = klass.providers.first
+      expect(instance.provider).to eq(:fake_provider)
+      expect(instance.parser).to eq(:fake_parser)
+    end
+  end
+
+  describe '#provider_for' do
+    it 'returns nil if no provider can be found' do
+      expect(klass.provider_for('foo')).to be_nil
+    end
+  end
+
+  describe '#split_uri' do
+    it 'separates the scheme and payload' do
+      expect(klass.split_uri('foo://bar')).to eq(%w(foo bar))
+    end
+
+    it 'determines that the scheme is nil if not given' do
+      expect(klass.split_uri('bar')).to eq([nil, 'bar'])
+    end
+  end
+
+  context 'with a registered provider' do
+    before(:each) do
+      klass.register_provider(provider, :fake_parser)
+    end
+
+    describe '#provider_for' do
+      it 'finds the first provider that matches the given scheme' do
+        instance = klass.provider_for('test')
+        expect(instance.provider).to eq(provider)
+        expect(instance.parser).to eq(:fake_parser)
+      end
+    end
+  end
+end

data/spec/config/tx_config_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+
+include Txgh::Config
+
+describe TxConfig do
+  include StandardTxghSetup
+
+  describe '.load' do
+    it 'parses the config correctly' do
+      config_str = """
+        [main]
+        host = https://www.transifex.com
+        lang_map = pt-BR:pt, ko-KR:ko
+
+        [my_proj.my_resource]
+        file_filter = translations/<lang>/sample.po
+        source_file = sample.po
+        source_lang = en
+        type = PO
+      """
+
+      config = TxConfig.load(config_str)
+      expect(config.lang_map).to eq('pt-BR' => 'pt', 'ko-KR' => 'ko')
+      expect(config.resources.size).to eq(1)
+
+      resource = config.resources.first
+      expect(resource.project_slug).to eq('my_proj')
+      expect(resource.resource_slug).to eq('my_resource')
+      expect(resource.source_file).to eq('sample.po')
+      expect(resource.source_lang).to eq('en')
+      expect(resource.translation_file).to eq('translations/<lang>/sample.po')
+      expect(resource.type).to eq('PO')
+    end
+  end
+
+  describe '#resource' do
+    it 'finds the resource by slug' do
+      resource = tx_config.resource(resource_slug)
+      expect(resource).to be_a(TxResource)
+      expect(resource.resource_slug).to eq(resource_slug)
+    end
+
+    it 'returns nil if there is no resource with the given slug' do
+      resource = tx_config.resource('foobarbaz')
+      expect(resource).to be_nil
+    end
+  end
+end

data/spec/config/tx_manager_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'helpers/standard_txgh_setup'
+
+include Txgh
+include Txgh::Config
+
+describe TxManager do
+  include StandardTxghSetup
+
+  describe '.tx_config' do
+    let(:config) { KeyManager.config_from(project_name, repo_name) }
+    let(:project) { config.transifex_project }
+    let(:repo) { config.github_repo }
+
+    it 'loads tx config from the given file' do
+      path = 'file://path/to/tx_config'
+      project_config.merge!('tx_config' => path)
+      expect(TxConfig).to receive(:load_file).with('path/to/tx_config').and_return(:tx_config)
+      config = TxManager.tx_config(project, repo)
+      expect(config).to eq(:tx_config)
+    end
+
+    context 'with git-based config' do
+      before(:each) do
+        project_config.merge!('tx_config' => 'git://./tx.config')
+      end
+
+      it 'raises an error if asked to load config from a git repository and no ref is given' do
+        expect { TxManager.tx_config(project, repo) }.to raise_error(TxghError)
+      end
+
+      it "raises an error if the git repo doesn't contain the requested config file" do
+        expect(repo.api).to receive(:download).and_raise(Octokit::NotFound)
+        expect { TxManager.tx_config(project, repo, 'my_branch') }.to(
+          raise_error(ConfigNotFoundError)
+        )
+      end
+
+      it 'loads tx config from a git repository' do
+        expect(repo.api).to(
+          receive(:download)
+            .with(repo.name, './tx.config', 'my_branch')
+            .and_return("[main]\nlang_map = ko:ko_KR")
+        )
+
+        config = TxManager.tx_config(project, repo, 'my_branch')
+        expect(config.lang_map).to eq({ 'ko' => 'ko_KR' })
+      end
+    end
+
+    it 'loads raw tx config' do
+      project_config.merge!('tx_config' => "raw://[main]\nlang_map = ko:ko_KR")
+      config = TxManager.tx_config(project, repo)
+      expect(config.lang_map).to eq({ 'ko' => 'ko_KR' })
+    end
+  end
+end

data/spec/diff_calculator_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+include Txgh
+
+describe DiffCalculator do
+  def phrase(key, string)
+    { 'key' => key, 'string' => string }
+  end
+
+  describe '.compare' do
+    let(:diff) do
+      DiffCalculator.compare(head_phrases, diff_point_phrases)
+    end
+
+    context 'with phrases added to HEAD' do
+      let(:head_phrases) do
+        diff_point_phrases + [
+          phrase('TheNextGeneration', 'Jean Luc Picard')
+        ]
+      end
+
+      let(:diff_point_phrases) do
+        [
+          phrase('Voyager', 'Kathryn Janeway'),
+          phrase('DeepSpaceNine', 'Benjamin Sisko'),
+        ]
+      end
+
+      it 'includes the new string' do
+        expect(diff[:added].size).to eq(1)
+        expect(diff[:modified].size).to eq(0)
+        phrase = diff[:added].first
+        expect(phrase['key']).to eq('TheNextGeneration')
+        expect(phrase['string']).to eq('Jean Luc Picard')
+      end
+    end
+
+    context 'with phrases removed from HEAD' do
+      let(:head_phrases) do
+        []
+      end
+
+      let(:diff_point_phrases) do
+        [phrase('Voyager', 'Kathryn Janeway')]
+      end
+
+      it 'does not include the new string if string has been removed' do
+        expect(diff[:added].size).to eq(0)
+        expect(diff[:modified].size).to eq(0)
+      end
+    end
+
+    context 'with phrases modified in HEAD' do
+      let(:head_phrases) do
+        [phrase('TheNextGeneration', 'Jean Luc Picard (rocks)')]
+      end
+
+      let(:diff_point_phrases) do
+        [phrase('TheNextGeneration', 'Jean Luc Picard')]
+      end
+
+      it 'includes the modified string' do
+        expect(diff[:added].size).to eq(0)
+        expect(diff[:modified].size).to eq(1)
+        phrase = diff[:modified].first
+        expect(phrase['key']).to eq('TheNextGeneration')
+        expect(phrase['string']).to eq('Jean Luc Picard (rocks)')
+      end
+    end
+
+    context 'with no phrases modified, added, or removed' do
+      let(:head_phrases) do
+        [
+          phrase('TheNextGeneration', 'Jean Luc Picard'),
+          phrase('Voyager', 'Kathryn Janeway'),
+          phrase('DeepSpaceNine', 'Benjamin Sisko')
+        ]
+      end
+
+      let(:diff_point_phrases) do
+        head_phrases
+      end
+
+      it 'does not include any phrases' do
+        expect(diff[:added].size).to eq(0)
+        expect(diff[:modified].size).to eq(0)
+      end
+    end
+  end
+end

data/spec/github_api_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+include Txgh
+
+describe GithubApi do
+  let(:client) { double(:client) }
+  let(:api) { GithubApi.create_from_client(client) }
+  let(:repo) { 'my_org/my_repo' }
+  let(:branch) { 'master' }
+  let(:sha) { 'abc123' }
+
+  describe '#tree' do
+    it 'retrieves a git tree using the client' do
+      expect(client).to receive(:tree).with(repo, sha, recursive: 1)
+      api.tree(repo, sha)
+    end
+  end
+
+  describe '#blob' do
+    it 'retrieves a git blob using the client' do
+      expect(client).to receive(:blob).with(repo, sha)
+      api.blob(repo, sha)
+    end
+  end
+
+  describe '#create_ref' do
+    it 'creates the given ref using the client' do
+      expect(client).to receive(:create_ref).with(repo, branch, sha)
+      api.create_ref(repo, branch, sha)
+    end
+
+    it 'returns false on client error' do
+      expect(client).to receive(:create_ref).and_raise(StandardError)
+      expect(api.create_ref(repo, branch, sha)).to eq(false)
+    end
+  end
+
+  describe '#commit' do
+    let(:path) { 'path/to/translations' }
+    let(:other_path) { 'other/path/to/translations' }
+
+    before(:each) do
+      allow(client).to receive(:create_blob).with(repo, :new_content).and_return(:blob_sha)
+      allow(client).to receive(:ref).with(repo, branch).and_return(object: { sha: :branch_sha })
+      allow(client).to receive(:commit).with(repo, :branch_sha).and_return(commit: { tree: { sha: :base_tree_sha } })
+      allow(client).to receive(:create_tree).and_return(sha: :new_tree_sha)
+    end
+
+    it 'creates a new commit and updates the branch' do
+      expect(client).to(
+        receive(:create_commit)
+          .with(repo, "Updating translations for #{path}", :new_tree_sha, :branch_sha)
+          .and_return(sha: :new_commit_sha)
+      )
+
+      expect(client).to receive(:update_ref).with(repo, branch, :new_commit_sha, false)
+      api.commit(repo, branch, { path => :new_content }, true)
+    end
+
+    it 'updates multiple files at a time' do
+      allow(client).to receive(:create_blob).with(repo, :other_content).and_return(:blob_sha_2)
+
+      expect(client).to(
+        receive(:create_commit)
+          .with(repo, "Updating translations for #{path}, #{other_path}", :new_tree_sha, :branch_sha)
+          .and_return(sha: :new_commit_sha)
+      )
+
+      expect(client).to receive(:update_ref).with(repo, branch, :new_commit_sha, false)
+      content_map = { path => :new_content, other_path => :other_content }
+      api.commit(repo, branch, content_map, true)
+    end
+
+    context 'with an empty commit' do
+      before(:each) do
+        allow(client).to(
+          receive(:compare)
+            .with(repo, :branch_sha, :new_commit_sha)
+            .and_return(files: [])
+        )
+
+        expect(client).to(
+          receive(:create_commit)
+            .with(repo, "Updating translations for #{path}", :new_tree_sha, :branch_sha)
+            .and_return(sha: :new_commit_sha)
+        )
+      end
+
+      it 'does not allow empty commits by default' do
+        expect(client).to_not receive(:update_ref)
+        api.commit(repo, branch, { path => :new_content })
+      end
+    end
+
+    context 'with a non-empty commit' do
+      before(:each) do
+        allow(client).to(
+          receive(:compare)
+            .with(repo, :branch_sha, :new_commit_sha)
+            .and_return(files: %w(abc def))
+        )
+
+        expect(client).to(
+          receive(:create_commit)
+            .with(repo, "Updating translations for #{path}", :new_tree_sha, :branch_sha)
+            .and_return(sha: :new_commit_sha)
+        )
+      end
+
+      it 'updates the ref as expected' do
+        expect(client).to receive(:update_ref).with(repo, branch, :new_commit_sha, false)
+        api.commit(repo, branch, { path => :new_content })
+      end
+    end
+  end
+
+  describe '#get_commit' do
+    it 'retrieves the given commit using the client' do
+      expect(client).to receive(:commit).with(repo, sha)
+      api.get_commit(repo, sha)
+    end
+  end
+
+  describe '#get_ref' do
+    it 'retrieves the given ref (i.e. branch) using the client' do
+      expect(client).to receive(:ref).with(repo, sha)
+      api.get_ref(repo, sha)
+    end
+  end
+
+  describe '#download' do
+    it 'downloads the file from the given branch' do
+      path = 'path/to/file.xyz'
+
+      expect(client).to receive(:ref).with(repo, branch).and_return(object: { sha: :branch_sha })
+      expect(client).to receive(:commit).with(repo, :branch_sha).and_return(commit: { tree: { sha: :base_tree_sha } })
+      expect(client).to receive(:tree).with(repo, :base_tree_sha, recursive: 1).and_return(
+        tree: [{ path: path, sha: :blob_sha }]
+      )
+
+      expect(client).to receive(:blob).with(repo, :blob_sha).and_return(
+        { 'content' => :blob, 'encoding' => 'utf-8' }
+      )
+
+      expect(api.download(repo, path, branch)).to eq(:blob)
+    end
+  end
+end