txgh 6.8.1 → 7.0.0.beta

data/lib/txgh/github_status.rb

@@ -1,151 +1,4 @@
-require 'celluloid/current'
-
 module Txgh
-  class GithubStatus
-    class State
-      PENDING = 'pending'
-      SUCCESS = 'success'
-      ERROR   = 'error'
-      FAILURE = 'failure'
-
-      class << self
-        def pending; PENDING; end
-        def success; SUCCESS; end
-        def error; ERROR; end
-        def failure; failure; end
-      end
-    end
-
-    ALL_COMPLETE_DESCRIPTION = "Translations complete!"
-    TARGET_URL_TEMPLATE = "https://www.transifex.com/%{organization}/%{project_slug}/content"
-    DESCRIPTION_TEMPLATE = "%{complete}/%{total} translations complete."
-    CONTEXT = 'continuous-localization/txgh'
-
-    class << self
-      def update(project, repo, branch)
-        new(project, repo, branch).update
-      end
-
-      def error(project, repo, branch, options = {})
-        new(project, repo, branch).error(options)
-      end
-    end
-
-    attr_reader :project, :repo, :branch
-
-    def initialize(project, repo, branch)
-      @project = project
-      @repo = repo
-      @branch = branch
-    end
-
-    def update
-      return if tx_resources.empty?
-
-      repo.api.create_status(
-        sha, state, {
-          context: context, target_url: target_url, description: description
-        }
-      )
-    end
-
-    def error(options = {})
-      repo.api.create_status(
-        sha, State.error, {
-          context: context,
-          target_url: options.fetch(:target_url),
-          description: options.fetch(:description)
-        }
-      )
-    end
-
-    private
-
-    def sha
-      ref[:object][:sha]
-    end
-
-    def ref
-      @ref ||= repo.api.get_ref(branch)
-    end
-
-    def context
-      CONTEXT
-    end
-
-    def target_url
-      # assume all resources are from the same project
-      TARGET_URL_TEMPLATE % {
-        organization: project.organization,
-        project_slug: tx_resources.first.project_slug
-      }
-    end
-
-    def state
-      if all_complete?
-        State.success
-      else
-        State.pending
-      end
-    end
-
-    def description
-      if all_complete?
-        ALL_COMPLETE_DESCRIPTION
-      else
-        DESCRIPTION_TEMPLATE % stat_totals
-      end
-    end
-
-    def all_complete?
-      stats.all? do |resource_stats|
-        resource_stats.all? do |locale, details|
-          details['completed'] == '100%'
-        end
-      end
-    end
-
-    def stat_totals
-      @stat_totals ||= { complete: 0, total: 0 }.tap do |counts|
-        stats.each do |resource_stats|
-          resource_stats.each_pair do |locale, details|
-            counts[:total] += details['translated_entities'] + details['untranslated_entities']
-            counts[:complete] += details['translated_entities']
-          end
-        end
-      end
-    end
-
-    def stats
-      @stats ||= tx_resources.map do |tx_resource|
-        Celluloid::Future.new { project.api.get_stats(*tx_resource.slugs) }
-      end.map(&:value)
-    end
-
-    def tx_resources
-      @tx_resources ||=
-        tx_config.resources.each_with_object([]) do |tx_resource, ret|
-          if repo.process_all_branches?
-            tx_resource = Txgh::TxBranchResource.new(tx_resource, branch)
-          end
-
-          next unless existing_slugs.include?(tx_resource.resource_slug)
-          ret << tx_resource
-        end
-    end
-
-    def existing_slugs
-      @existing_slugs ||= existing_resources.map do |resource|
-        resource['slug']
-      end
-    end
-
-    def existing_resources
-      @existing_resources ||= project.api.get_resources(project.name)
-    end
-
-    def tx_config
-      @tx_config ||= Txgh::Config::TxManager.tx_config(project, repo, branch)
-    end
+  class GithubStatus < GitStatus
   end
 end

data/lib/txgh/gitlab_api.rb

@@ -0,0 +1,63 @@
+require 'gitlab'
+
+module Txgh
+  class GitlabApi < GitApi
+    class << self
+      def create_from_credentials(_login, access_token, repo_name)
+        Gitlab.endpoint = 'https://gitlab.com/api/v4'
+        create_from_client(
+          Gitlab.client(private_token: access_token),
+          repo_name
+        )
+      end
+    end
+
+    def update_contents(branch, content_list, message)
+      content_list.each do |file_params|
+        path = file_params.fetch(:path)
+        new_contents = file_params.fetch(:contents)
+        branch = Utils.relative_branch(branch)
+
+        file_sha = file_params.fetch(:sha) do
+          begin
+            client.get_file(repo_name, path, branch).content_sha256
+          rescue ::Gitlab::Error::NotFound
+            nil
+          end
+        end
+
+        # If the file doesnt exist, then it isn't tracked by git and file_sha
+        # will be nil. In git land, a SHA of all zeroes means create a new file
+        # instead of updating an existing one.
+        current_sha = file_sha || '0' * 40
+        new_sha = Utils.git_hash_blob(new_contents)
+
+        if current_sha != new_sha
+          client.edit_file(repo_name, path, branch, new_contents, message)
+        end
+      end
+    end
+
+    def get_ref(ref)
+      # mock github response
+      {
+        object: {
+          sha: client.commit(repo_name, ref.gsub('heads/', '')).short_id
+        }
+      }
+    end
+
+    def download(path, branch)
+      file = client.get_file(repo_name, path, branch.gsub('heads/', ''))
+
+      # mock github response
+      {
+        content: file.encoding == 'base64' ? Base64.decode64(file.content) : file.content.force_encoding(file.encoding)
+      }
+    end
+
+    def create_status(sha, state, options = {})
+      client.update_commit_status(repo_name, sha, state, options)
+    end
+  end
+end

data/lib/txgh/gitlab_repo.rb

@@ -0,0 +1,4 @@
+module Txgh
+  class GitlabRepo < Txgh::GitRepo
+  end
+end

data/lib/txgh/gitlab_status.rb

@@ -0,0 +1,4 @@
+module Txgh
+  class GitlabStatus < Txgh::GitStatus
+  end
+end

data/lib/txgh/version.rb

@@ -1,3 +1,3 @@
 module Txgh
-  VERSION = '6.8.1'
+  VERSION = '7.0.0.beta'
 end

data/lib/txgh.rb

@@ -7,9 +7,15 @@ module Txgh
   autoload :DiffCalculator,        'txgh/diff_calculator'
   autoload :EmptyResourceContents, 'txgh/empty_resource_contents'
   autoload :Events,                'txgh/events'
+  autoload :GitApi,                'txgh/git_api'
   autoload :GithubApi,             'txgh/github_api'
+  autoload :GitlabApi,             'txgh/gitlab_api'
+  autoload :GitRepo,               'txgh/git_repo'
   autoload :GithubRepo,            'txgh/github_repo'
+  autoload :GitlabRepo,            'txgh/gitlab_repo'
+  autoload :GitStatus,             'txgh/git_status'
   autoload :GithubStatus,          'txgh/github_status'
+  autoload :GitlabStatus,          'txgh/gitlab_status'
   autoload :MergeCalculator,       'txgh/merge_calculator'
   autoload :ParseConfig,           'txgh/parse_config'
   autoload :Puller,                'txgh/puller'
@@ -51,9 +57,10 @@ module Txgh
   end
 
   # default set of tx config providers
-  tx_manager.register_provider(providers::FileProvider, Txgh::Config::TxConfig)
-  tx_manager.register_provider(providers::GitProvider,  Txgh::Config::TxConfig)
-  tx_manager.register_provider(providers::RawProvider,  Txgh::Config::TxConfig, default: true)
+  tx_manager.register_provider(providers::FileProvider,   Txgh::Config::TxConfig)
+  tx_manager.register_provider(providers::GithubProvider, Txgh::Config::TxConfig)
+  tx_manager.register_provider(providers::GitlabProvider, Txgh::Config::TxConfig)
+  tx_manager.register_provider(providers::RawProvider,    Txgh::Config::TxConfig, default: true)
 
   # default set of base config providers
   key_manager.register_provider(providers::FileProvider, YAML)

data/spec/category_support_spec.rb

@@ -1,18 +1,16 @@
 require 'spec_helper'
 
-include Txgh
-
-describe CategorySupport do
+describe Txgh::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)
+      result = described_class.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)
+      result = described_class.deserialize_categories(categories)
       expect(result).to eq('captain' => 'janeway', 'commander' => 'chakotay')
     end
   end
@@ -20,14 +18,14 @@ describe CategorySupport do
   describe '.serialize_categories' do
     it 'converts a hash of categories into an array' do
       categories = { 'captain' => 'janeway', 'commander' => 'chakotay' }
-      result = CategorySupport.serialize_categories(categories)
+      result = described_class.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(
+      expect(described_class.escape_category('Katherine Janeway')).to(
         eq('Katherine_Janeway')
       )
     end
@@ -35,7 +33,7 @@ describe CategorySupport do
 
   describe '.join_categories' do
     it 'joins an array of categories by spaces' do
-      expect(CategorySupport.join_categories(%w(foo:bar baz:boo))).to(
+      expect(described_class.join_categories(%w(foo:bar baz:boo))).to(
         eq('foo:bar baz:boo')
       )
     end

data/spec/config/config_pair_spec.rb

@@ -1,28 +1,41 @@
 require 'spec_helper'
 require 'helpers/standard_txgh_setup'
 
-include Txgh::Config
-
-describe ConfigPair do
+describe Txgh::Config::ConfigPair do
   include StandardTxghSetup
 
   let(:config) do
-    ConfigPair.new(project_config, repo_config)
+    described_class.new(project_config, github_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)
+  describe '#git_repo' do
+    context 'Github' do
+      it 'instantiates a github repo with the right config' do
+        repo = config.git_repo
+        expect(repo).to be_a(Txgh::GithubRepo)
+        expect(repo.name).to eq(github_repo_name)
+        expect(repo.branch).to eq(branch)
+      end
+    end
+
+    context 'Gitlab' do
+      let(:config) do
+        described_class.new(project_config, gitlab_config)
+      end
+
+      it 'instantiates a github repo with the right config' do
+        repo = config.git_repo
+        expect(repo).to be_a(Txgh::GitlabRepo)
+        expect(repo.name).to eq(gitlab_repo_name)
+        expect(repo.branch).to eq(branch)
+      end
     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).to be_a(Txgh::TransifexProject)
       expect(project.name).to eq(project_name)
       expect(tx_config.resources.first.resource_slug).to eq(resource_slug)
     end
@@ -31,17 +44,29 @@ describe ConfigPair do
   describe '#transifex_api' do
     it 'instantiates an API instance' do
       api = config.transifex_api
-      expect(api).to be_a(TransifexApi)
+      expect(api).to be_a(Txgh::TransifexApi)
       expect(api.connection.headers).to include('Authorization')
     end
   end
 
   describe '#github_api' do
-    it 'instantiates an API instance' do
+    it 'instantiates a github 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'])
+      expect(api).to be_a(Txgh::GithubApi)
+      expect(api.client.login).to eq(github_config['api_username'])
+      expect(api.client.access_token).to eq(github_config['api_token'])
+    end
+  end
+
+  describe '#gitlab_api' do
+    let(:config) do
+      described_class.new(project_config, gitlab_config)
+    end
+
+    it 'instantiates a gitlab API instance' do
+      api = config.gitlab_api
+      expect(api).to be_a(Txgh::GitlabApi)
+      expect(api.client.private_token).to eq(gitlab_config['api_token'])
     end
   end
 end

data/spec/config/key_manager_spec.rb

@@ -13,10 +13,22 @@ describe KeyManager do
       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)
+    context 'Github' do
+      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(github_config)
+      end
+    end
+
+    context 'Gitlab' do
+      let(:push_translations_to) { gitlab_repo_name }
+
+      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(gitlab_config)
+      end
     end
 
     it "raises an error if config can't be found" do
@@ -39,14 +51,21 @@ describe KeyManager do
 
   describe '.config_from_repo' do
     it 'creates a config object' do
-      config = KeyManager.config_from_repo(repo_name)
+      config = KeyManager.config_from_repo(github_repo_name)
+      expect(config).to be_a(Txgh::Config)
+
+      config = KeyManager.config_from_repo(gitlab_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)
+      config = KeyManager.config_from_repo(github_repo_name)
+      expect(config.project_config).to eq(project_config)
+      expect(config.repo_config).to eq(github_config)
+
+      config = KeyManager.config_from_repo(gitlab_repo_name)
       expect(config.project_config).to eq(project_config)
-      expect(config.repo_config).to eq(repo_config)
+      expect(config.repo_config).to eq(gitlab_config)
     end
 
     it "raises an error if config can't be found" do
@@ -61,7 +80,7 @@ describe KeyManager do
         receive(:raw_config).and_return(YAML.dump(base_config))
       )
 
-      expect { KeyManager.config_from_repo(repo_name) }.to(
+      expect { KeyManager.config_from_repo(github_repo_name) }.to(
         raise_error(InvalidProviderError)
       )
     end
@@ -69,14 +88,14 @@ describe KeyManager do
 
   describe '.config_from' do
     it 'creates a config object' do
-      config = KeyManager.config_from(project_name, repo_name)
+      config = KeyManager.config_from(project_name, github_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)
+      config = KeyManager.config_from(project_name, github_repo_name)
       expect(config.project_config).to eq(project_config)
-      expect(config.repo_config).to eq(repo_config)
+      expect(config.repo_config).to eq(github_config)
     end
   end
 
@@ -85,10 +104,4 @@ describe KeyManager do
       expect(KeyManager.project_names).to eq([project_name])
     end
   end
-
-  describe '#repo_names' do
-    it "gets an array of all the configured repo's names" do
-      expect(KeyManager.repo_names).to eq([repo_name])
-    end
-  end
 end

data/spec/config/provider_instance_spec.rb

@@ -1,15 +1,12 @@
 require 'spec_helper'
 require 'helpers/test_provider'
 
-include Txgh
-include Txgh::Config
-
-describe ProviderInstance do
+describe Txgh::Config::ProviderInstance do
   let(:provider) { TestProvider }
   let(:payload) { :fake_payload }
   let(:parser) { :fake_parser }
   let(:options) { :fake_options }
-  let(:instance) { ProviderInstance.new(provider, parser) }
+  let(:instance) { described_class.new(provider, parser) }
 
   describe '#supports?' do
     it 'returns true if the scheme matches' do
@@ -27,7 +24,7 @@ describe ProviderInstance do
     end
 
     context 'with a default provider' do
-      let(:instance) { ProviderInstance.new(provider, parser, default: true) }
+      let(:instance) { described_class.new(provider, parser, default: true) }
 
       it 'returns true if marked as the default provider' do
         expect(instance).to be_default

data/spec/config/provider_support_spec.rb

@@ -1,12 +1,9 @@
 require 'spec_helper'
 require 'helpers/test_provider'
 
-include Txgh
-include Txgh::Config
-
-describe ProviderSupport do
+describe Txgh::Config::ProviderSupport do
   let(:klass) do
-    Class.new { extend ProviderSupport }
+    Class.new { extend Txgh::Config::ProviderSupport }
   end
 
   let(:provider) { TestProvider }

data/spec/config/tx_config_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 require 'helpers/standard_txgh_setup'
 
-include Txgh::Config
-
-describe TxConfig do
+describe Txgh::Config::TxConfig do
   include StandardTxghSetup
 
   describe '.load' do
@@ -20,7 +18,7 @@ describe TxConfig do
         type = PO
       """
 
-      config = TxConfig.load(config_str)
+      config = described_class.load(config_str)
       expect(config.lang_map).to eq('pt-BR' => 'pt', 'ko-KR' => 'ko')
       expect(config.resources.size).to eq(1)
 

data/spec/config/tx_manager_spec.rb

@@ -1,22 +1,19 @@
 require 'spec_helper'
 require 'helpers/standard_txgh_setup'
 
-include Txgh
-include Txgh::Config
-
-describe TxManager do
+describe Txgh::Config::TxManager do
   include StandardTxghSetup
 
   describe '.tx_config' do
-    let(:config) { KeyManager.config_from(project_name, repo_name) }
+    let(:config) { KeyManager.config_from(project_name, github_repo_name) }
     let(:project) { config.transifex_project }
-    let(:repo) { config.github_repo }
+    let(:repo) { config.git_repo }
 
     it 'loads tx config from the given file' do
       path = 'file://path/to/tx_config'
       project_config.merge!('tx_config' => path)
       expect(File).to receive(:read).with('path/to/tx_config').and_return('{}')
-      config = TxManager.tx_config(project, repo)
+      config = described_class.tx_config(project, repo)
       expect(config).to be_a(TxConfig)
     end
 
@@ -26,12 +23,12 @@ describe TxManager do
       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)
+        expect { described_class.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(
+        expect { described_class.tx_config(project, repo, 'my_branch') }.to(
           raise_error(GitConfigNotFoundError)
         )
       end
@@ -43,14 +40,14 @@ describe TxManager do
             .and_return(content: "[main]\nlang_map = ko:ko_KR")
         )
 
-        config = TxManager.tx_config(project, repo, 'my_branch')
+        config = described_class.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)
+      config = described_class.tx_config(project, repo)
       expect(config.lang_map).to eq({ 'ko' => 'ko_KR' })
     end
   end

data/spec/diff_calculator_spec.rb

@@ -1,15 +1,13 @@
 require 'spec_helper'
 
-include Txgh
-
-describe DiffCalculator do
+describe Txgh::DiffCalculator do
   def phrase(key, string)
     { 'key' => key, 'string' => string }
   end
 
   describe '.compare' do
     let(:diff) do
-      DiffCalculator.compare(head_phrases, diff_point_phrases)
+      described_class.compare(head_phrases, diff_point_phrases)
     end
 
     context 'with phrases added to HEAD' do

data/spec/events_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 
-include Txgh
-
-describe Events do
-  let(:events) { Events.new }
+describe Txgh::Events do
+  let(:events) { subject }
 
   describe '#subscribe and #channels' do
     it "adds a channel if it doesn't already exist" do

data/spec/github_api_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
 require 'base64'
 
-include Txgh
-
-describe GithubApi do
+describe Txgh::GithubApi do
   let(:client) { double(:client) }
-  let(:api) { GithubApi.create_from_client(client, repo) }
+  let(:api) { described_class.create_from_client(client, repo) }
   let(:repo) { 'my_org/my_repo' }
   let(:branch) { 'master' }
   let(:sha) { 'abc123' }