txgh 1.0.0

data/lib/txgh/empty_resource_contents.rb

@@ -0,0 +1,43 @@
+module Txgh
+  class EmptyResourceContents
+    attr_reader :tx_resource
+
+    def initialize(tx_resource)
+      @tx_resource = tx_resource
+    end
+
+    def phrases
+      []
+    end
+
+    def write_to(*args)
+      # no-op
+    end
+
+    def to_s(*args)
+      ''
+    end
+
+    def to_h
+      {}
+    end
+
+    def diff(other_contents)
+      other_contents
+    end
+
+    def diff_hash(other_contents)
+      DiffCalculator::INCLUDED_STATES.each_with_object({}) do |state, ret|
+        ret[state] = []
+      end
+    end
+
+    def merge(other_contents, *args)
+      other_contents
+    end
+
+    def empty?
+      true
+    end
+  end
+end

data/lib/txgh/errors.rb

@@ -0,0 +1,9 @@
+module Txgh
+  class TxghError < StandardError; end
+  class TxghInternalError < TxghError; end
+
+  class TransifexApiError < StandardError; end
+  class TransifexNotFoundError < TransifexApiError; end
+  class TransifexUnauthorizedError < TransifexApiError; end
+  class ConfigNotFoundError < StandardError; end
+end

data/lib/txgh/github_api.rb

@@ -0,0 +1,83 @@
+require 'base64'
+require 'octokit'
+
+module Txgh
+  class GithubApi
+    class << self
+      def create_from_credentials(login, access_token)
+        create_from_client(
+          Octokit::Client.new(login: login, access_token: access_token)
+        )
+      end
+
+      def create_from_client(client)
+        new(client)
+      end
+    end
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def tree(repo, sha)
+      client.tree(repo, sha, recursive: 1)
+    end
+
+    def blob(repo, sha)
+      client.blob(repo, sha)
+    end
+
+    def create_ref(repo, branch, sha)
+      client.create_ref(repo, branch, sha) rescue false
+    end
+
+    def commit(repo, branch, content_map, allow_empty = false)
+      parent = client.ref(repo, branch)
+      base_commit = get_commit(repo, parent[:object][:sha])
+
+      tree_data = content_map.map do |path, content|
+        blob = client.create_blob(repo, content)
+        { path: path, mode: '100644', type: 'blob', sha: blob }
+      end
+
+      tree_options = { base_tree: base_commit[:commit][:tree][:sha] }
+
+      tree = client.create_tree(repo, tree_data, tree_options)
+      commit = client.create_commit(
+        repo, "Updating translations for #{content_map.keys.join(", ")}",
+        tree[:sha], parent[:object][:sha]
+      )
+
+      # don't update the ref if the commit introduced no new changes
+      unless allow_empty
+        diff = client.compare(repo, parent[:object][:sha], commit[:sha])
+        return if diff[:files].empty?
+      end
+
+      # false means don't force push
+      client.update_ref(repo, branch, commit[:sha], false)
+    end
+
+    def get_commit(repo, sha)
+      client.commit(repo, sha)
+    end
+
+    def get_ref(repo, ref)
+      client.ref(repo, ref)
+    end
+
+    def download(repo, path, branch)
+      master = client.ref(repo, branch)
+      commit = client.commit(repo, master[:object][:sha])
+      tree = client.tree(repo, commit[:commit][:tree][:sha], recursive: 1)
+
+      if found = tree[:tree].find { |t| t[:path] == path }
+        b = blob(repo, found[:sha])
+        b['encoding'] == 'utf-8' ? b['content'] : Base64.decode64(b['content'])
+      end
+    end
+
+  end
+end

data/lib/txgh/github_repo.rb

@@ -0,0 +1,88 @@
+module Txgh
+  class GithubRepo
+    attr_reader :config, :api
+
+    def initialize(config, api)
+      @config = config
+      @api = api
+    end
+
+    def name
+      config['name']
+    end
+
+    def branch
+      config['branch']
+    end
+
+    def tag
+      config['tag']
+    end
+
+    def process_all_branches?
+      branch == 'all'
+    end
+
+    def upload_diffs?
+      !(diff_point || '').empty?
+    end
+
+    def diff_point
+      config['diff_point']
+    end
+
+    def process_all_tags?
+      tag == 'all'
+    end
+
+    def should_process_ref?(candidate)
+      if Utils.is_tag?(candidate)
+        should_process_tag?(candidate)
+      else
+        should_process_branch?(candidate)
+      end
+    end
+
+    def github_config_branch
+      @github_config_branch ||= begin
+        if process_all_branches?
+          'all'
+        else
+          Utils.absolute_branch(branch || 'master')
+        end
+      end
+    end
+
+    def github_config_tag
+      @github_config_tag ||= begin
+        if process_all_tags?
+          'all'
+        else
+          Utils.absolute_branch(tag) if tag
+        end
+      end
+    end
+
+    def webhook_secret
+      config['webhook_secret']
+    end
+
+    def webhook_protected?
+      !(webhook_secret || '').empty?
+    end
+
+    private
+
+    def should_process_branch?(candidate)
+      process_all_branches? ||
+        candidate.include?(github_config_branch) ||
+        candidate.include?('L10N')
+    end
+
+    def should_process_tag?(candidate)
+      process_all_tags? || (
+        github_config_tag && candidate.include?(github_config_tag)
+      )
+    end
+  end
+end

data/lib/txgh/github_request_auth.rb

@@ -0,0 +1,28 @@
+require 'openssl'
+
+module Txgh
+  class GithubRequestAuth
+    HMAC_DIGEST = OpenSSL::Digest.new('sha1')
+    RACK_HEADER = 'HTTP_X_HUB_SIGNATURE'
+    GITHUB_HEADER = 'X-Hub-Signature'
+
+    class << self
+      def authentic_request?(request, secret)
+        request.body.rewind
+        expected_signature = header_value(request.body.read, secret)
+        actual_signature = request.env[RACK_HEADER]
+        actual_signature == expected_signature
+      end
+
+      def header_value(content, secret)
+        "sha1=#{digest(content, secret)}"
+      end
+
+      private
+
+      def digest(content, secret)
+        OpenSSL::HMAC.hexdigest(HMAC_DIGEST, secret, content)
+      end
+    end
+  end
+end

data/lib/txgh/handlers.rb

@@ -0,0 +1,12 @@
+module Txgh
+  module Handlers
+    autoload :DownloadHandler,   'txgh/handlers/download_handler'
+    autoload :Github,            'txgh/handlers/github'
+    autoload :Response,          'txgh/handlers/response'
+    autoload :StreamResponse,    'txgh/handlers/stream_response'
+    autoload :TgzStreamResponse, 'txgh/handlers/tgz_stream_response'
+    autoload :Transifex,         'txgh/handlers/transifex'
+    autoload :Triggers,          'txgh/handlers/triggers'
+    autoload :ZipStreamResponse, 'txgh/handlers/zip_stream_response'
+  end
+end

data/lib/txgh/handlers/download_handler.rb

@@ -0,0 +1,84 @@
+module Txgh
+  module Handlers
+    class DownloadHandler
+      DEFAULT_FORMAT = '.zip'
+
+      # includes response helpers in both the class and the singleton class
+      include ResponseHelpers
+
+      class << self
+        def handle_request(request, logger = nil)
+          handle_safely do
+            config = config_from(request)
+            project, repo = [config.transifex_project, config.github_repo]
+            params = params_from(request)
+            handler = new(project, repo, params, logger)
+            handler.execute
+          end
+        end
+
+        private
+
+        def config_from(request)
+          Txgh::Config::KeyManager.config_from_project(
+            request.params.fetch('project_slug')
+          )
+        end
+
+        def params_from(request)
+          request.params.merge(
+            'format' => format_from(request)
+          )
+        end
+
+        def format_from(request)
+          # sinatra is dumb and doesn't include any of the URL captures in the
+          # request params or env hash
+          File.extname(request.env['REQUEST_PATH'])
+        end
+
+        def handle_safely
+          yield
+        rescue => e
+          respond_with_error(500, "Internal server error: #{e.message}", e)
+        end
+      end
+
+      attr_reader :project, :repo, :params, :logger
+
+      def initialize(project, repo, params, logger)
+        @project = project
+        @repo = repo
+        @params = params
+        @logger = logger
+      end
+
+      def execute
+        downloader = ResourceDownloader.new(project, repo, params['branch'])
+        response_class.new(attachment, downloader.each)
+      end
+
+      private
+
+      def attachment
+        project.name
+      end
+
+      def format
+        params.fetch('format', DEFAULT_FORMAT)
+      end
+
+      def response_class
+        case format
+          when '.zip'
+            ZipStreamResponse
+          when '.tgz'
+            TgzStreamResponse
+          else
+            raise TxghInternalError,
+              "'#{format}' is not a valid download format"
+        end
+      end
+    end
+  end
+end

data/lib/txgh/handlers/github.rb

@@ -0,0 +1,10 @@
+module Txgh
+  module Handlers
+    module Github
+      autoload :DeleteHandler,  'txgh/handlers/github/delete_handler'
+      autoload :Handler,        'txgh/handlers/github/handler'
+      autoload :PushHandler,    'txgh/handlers/github/push_handler'
+      autoload :RequestHandler, 'txgh/handlers/github/request_handler'
+    end
+  end
+end

data/lib/txgh/handlers/github/delete_handler.rb

@@ -0,0 +1,65 @@
+module Txgh
+  module Handlers
+    module Github
+      class DeleteHandler < Handler
+
+        include CategorySupport
+
+        def execute
+          delete_resources if should_handle_request?
+          respond_with(200, true)
+        end
+
+        private
+
+        def delete_resources
+          tx_resources.each do |tx_resource|
+            logger.info("Deleting #{tx_resource.resource_slug}")
+            project.api.delete(tx_resource)
+          end
+        end
+
+        def tx_resources
+          project.api.get_resources(project.name).map do |resource_hash|
+            categories = deserialize_categories(resource_hash['categories'])
+            resource_branch = Utils.absolute_branch(categories['branch'])
+
+            if resource_branch == branch
+              tx_branch_resource_from(resource_hash, branch)
+            end
+          end.compact
+        end
+
+        def tx_branch_resource_from(resource_hash, branch)
+          TxBranchResource.new(
+            tx_resource_from(resource_hash, branch), branch
+          )
+        end
+
+        # project_slug, resource_slug, type, source_lang, source_file, lang_map, translation_file
+        def tx_resource_from(resource_hash, branch)
+          TxResource.new(
+            project.name,
+            TxBranchResource.deslugify(resource_hash['slug'], branch),
+            resource_hash['i18n_type'],
+            resource_hash['source_language_code'],
+            resource_hash['name'],
+            '', nil
+          )
+        end
+
+        def should_handle_request?
+          # ref_type can be either 'branch' or 'tag' - we only care about branches
+          payload['ref_type'] == 'branch' &&
+            repo.should_process_ref?(branch) &&
+            project.auto_delete_resources?
+        end
+
+        def branch
+          Utils.absolute_branch(payload['ref'].sub(/^refs\//, ''))
+        end
+
+      end
+    end
+  end
+end

data/lib/txgh/handlers/github/handler.rb

@@ -0,0 +1,20 @@
+require 'logger'
+
+module Txgh
+  module Handlers
+    module Github
+      class Handler
+        include ResponseHelpers
+
+        attr_reader :project, :repo, :payload, :logger
+
+        def initialize(options = {})
+          @project = options.fetch(:project)
+          @repo = options.fetch(:repo)
+          @payload = options.fetch(:payload)
+          @logger = options.fetch(:logger) { Logger.new(STDOUT) }
+        end
+      end
+    end
+  end
+end