txgh 1.0.0

data/lib/txgh/resource_updater.rb

@@ -0,0 +1,104 @@
+require 'logger'
+
+module Txgh
+  class ResourceUpdater
+    include Txgh::CategorySupport
+
+    attr_reader :project, :repo, :logger
+
+    def initialize(project, repo, logger = nil)
+      @project = project
+      @repo = repo
+      @logger = logger || Logger.new(STDOUT)
+    end
+
+    # For each modified resource, get its content and update the content
+    # in Transifex.
+    def update_resource(tx_resource, commit_sha, categories = {})
+      logger.info('process updated resource')
+      tree_sha = repo.api.get_commit(repo.name, commit_sha)['commit']['tree']['sha']
+      tree = repo.api.tree(repo.name, tree_sha)
+
+      tree['tree'].each do |file|
+        logger.info("process each tree entry: #{file['path']}")
+
+        if tx_resource.source_file == file['path']
+          if repo.upload_diffs?
+            upload_diff(tx_resource, file, categories)
+          else
+            upload_whole(tx_resource, file, categories)
+          end
+        end
+      end
+    end
+
+    private
+
+    def upload_whole(tx_resource, file, categories)
+      content = contents_of(file['sha'])
+
+      if repo.process_all_branches?
+        upload_by_branch(tx_resource, content, categories)
+      else
+        upload(tx_resource, content)
+      end
+    end
+
+    def upload_diff(tx_resource, file, categories)
+      if content = diff_content(tx_resource, file)
+        upload_by_branch(tx_resource, content, categories)
+      end
+    end
+
+    def diff_content(tx_resource, file)
+      diff = head_content(tx_resource, file).diff(
+        diff_point_content(tx_resource, file)
+      )
+
+      diff.to_s unless diff.empty?
+    end
+
+    def head_content(tx_resource, file)
+      ResourceContents.from_string(tx_resource, contents_of(file['sha']))
+    end
+
+    def diff_point_content(tx_resource, file)
+      raw_content = repo.api.download(repo.name, file['path'], repo.diff_point)
+      ResourceContents.from_string(tx_resource, raw_content)
+    end
+
+    def upload(tx_resource, content)
+      project.api.create_or_update(tx_resource, content)
+    end
+
+    def upload_by_branch(tx_resource, content, additional_categories)
+      resource_exists = project.api.resource_exists?(tx_resource)
+      categories = resource_exists ? categories_for(tx_resource) : {}
+      categories.merge!(additional_categories)
+      categories['branch'] ||= tx_resource.branch
+      categories = serialize_categories(categories)
+
+      if resource_exists
+        project.api.update_details(tx_resource, categories: categories)
+        project.api.update_content(tx_resource, content)
+      else
+        project.api.create(tx_resource, content, categories)
+      end
+    end
+
+    def categories_for(tx_resource)
+      resource = project.api.get_resource(*tx_resource.slugs)
+      deserialize_categories(Array(resource['categories']))
+    end
+
+    def contents_of(sha)
+      blob = repo.api.blob(repo.name, sha)
+
+      if blob['encoding'] == 'utf-8'
+        blob['content']
+      else
+        Base64.decode64(blob['content'])
+      end
+    end
+  end
+end

data/lib/txgh/response_helpers.rb

@@ -0,0 +1,30 @@
+module Txgh
+  module ResponseHelpers
+    private
+
+    def respond_with(status, body, e = nil)
+      Txgh::Handlers::Response.new(status, body, e)
+    end
+
+    def respond_with_success(status, body)
+      respond_with(status, data(body))
+    end
+
+    def respond_with_error(status, message, e = nil)
+      respond_with(status, error(message), e)
+    end
+
+    def error(message)
+      [{ error: message }]
+    end
+
+    def data(body)
+      { data: body }
+    end
+
+    # includes these methods in the singleton class as well
+    def self.included(base)
+      base.extend(self)
+    end
+  end
+end

data/lib/txgh/transifex_api.rb

@@ -0,0 +1,165 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+require 'set'
+
+module Txgh
+  class TransifexApi
+    API_ROOT = '/api/2'
+
+    class << self
+      def create_from_credentials(username, password)
+        connection = Faraday.new(url: 'https://www.transifex.com') do |faraday|
+          faraday.request(:multipart)
+          faraday.request(:json)
+          faraday.request(:url_encoded)
+
+          faraday.response(:logger)
+          faraday.use(FaradayMiddleware::FollowRedirects)
+          faraday.adapter(Faraday.default_adapter)
+        end
+
+        connection.basic_auth(username, password)
+        connection.headers.update(Accept: 'application/json')
+        create_from_connection(connection)
+      end
+
+      def create_from_connection(connection)
+        new(connection)
+      end
+    end
+
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def create_or_update(tx_resource, content, categories = [])
+      if resource_exists?(tx_resource)
+        resource = get_resource(*tx_resource.slugs)
+        new_categories = Set.new(resource['categories'])
+        new_categories.merge(categories)
+
+        # update details first so new content is always tagged
+        update_details(tx_resource, categories: new_categories.to_a)
+        update_content(tx_resource, content)
+      else
+        create(tx_resource, content, categories)
+      end
+    end
+
+    def create(tx_resource, content, categories = [])
+      payload = {
+        slug: tx_resource.resource_slug,
+        name: tx_resource.source_file,
+        i18n_type: tx_resource.type,
+        categories: CategorySupport.join_categories(categories.uniq),
+        content: get_content_io(tx_resource, content)
+      }
+
+      url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resources/"
+      response = connection.post(url, payload)
+      raise_error!(response)
+    end
+
+    def delete(tx_resource)
+      url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resource/#{tx_resource.resource_slug}/"
+      connection.delete(url)
+    end
+
+    def update_content(tx_resource, content)
+      content_io = get_content_io(tx_resource, content)
+      payload = { content: content_io }
+      url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resource/#{tx_resource.resource_slug}/content/"
+      response = connection.put(url, payload)
+      raise_error!(response)
+    end
+
+    def update_details(tx_resource, details = {})
+      url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resource/#{tx_resource.resource_slug}/"
+      response = connection.put(url, details)
+      raise_error!(response)
+    end
+
+    def resource_exists?(tx_resource)
+      project = tx_resource.project_slug
+      slug = tx_resource.resource_slug
+      response = connection.get("#{API_ROOT}/project/#{project}/resource/#{slug}/")
+      response.status == 200
+    end
+
+    def download(tx_resource, lang)
+      project_slug = tx_resource.project_slug
+      resource_slug = tx_resource.resource_slug
+      response = connection.get(
+        "#{API_ROOT}/project/#{project_slug}/resource/#{resource_slug}/translation/#{lang}/"
+      )
+
+      raise_error!(response)
+
+      json_data = JSON.parse(response.body)
+      json_data['content']
+    end
+
+    def get_resource(project_slug, resource_slug)
+      url = "#{API_ROOT}/project/#{project_slug}/resource/#{resource_slug}/"
+      response = connection.get(url)
+      raise_error!(response)
+      JSON.parse(response.body)
+    end
+
+    def get_resources(project_slug)
+      url = "#{API_ROOT}/project/#{project_slug}/resources/"
+      response = connection.get(url)
+      raise_error!(response)
+      JSON.parse(response.body)
+    end
+
+    def get_languages(project_slug)
+      url = "#{API_ROOT}/project/#{project_slug}/languages/"
+      response = connection.get(url)
+      raise_error!(response)
+      JSON.parse(response.body)
+    end
+
+    def get_project(project_slug)
+      url = "#{API_ROOT}/project/#{project_slug}/"
+      response = connection.get(url)
+      raise_error!(response)
+      JSON.parse(response.body)
+    end
+
+    def get_formats
+      url = "#{API_ROOT}/formats/"
+      response = connection.get(url)
+      raise_error!(response)
+      JSON.parse(response.body)
+    end
+
+    private
+
+    def get_content_io(tx_resource, content)
+      content_io = StringIO::new(content)
+      content_io.set_encoding(Encoding::UTF_8.name)
+      Faraday::UploadIO.new(
+        content_io, 'application/octet-stream', tx_resource.source_file
+      )
+    end
+
+    def raise_error!(response)
+      case response.status
+        when 401
+          raise TransifexUnauthorizedError
+        when 404
+          raise TransifexNotFoundError
+        else
+          if (response.status / 100) != 2
+            raise TransifexApiError,
+              "Failed Transifex API call - returned status code: #{response.status}, body: #{response.body}"
+          end
+      end
+    end
+  end
+end
+

data/lib/txgh/transifex_project.rb

@@ -0,0 +1,37 @@
+module Txgh
+  class TransifexProject
+    attr_reader :config, :api
+
+    def initialize(config, api)
+      @config = config
+      @api = api
+    end
+
+    def name
+      config['name']
+    end
+
+    def webhook_secret
+      config['webhook_secret']
+    end
+
+    def protected_branches
+      @protected_branches ||=
+        (config['protected_branches'] || '').split(',').map do |branch|
+          Utils.absolute_branch(branch.strip)
+        end
+    end
+
+    def webhook_protected?
+      !(webhook_secret || '').empty?
+    end
+
+    def auto_delete_resources?
+      (config['auto_delete_resources'] || '').downcase == 'true'
+    end
+
+    def tx_config_uri
+      config['tx_config']
+    end
+  end
+end

data/lib/txgh/transifex_request_auth.rb

@@ -0,0 +1,53 @@
+require 'openssl'
+
+module Txgh
+  class TransifexRequestAuth
+    HMAC_DIGEST = OpenSSL::Digest.new('sha1')
+    RACK_HEADER = 'HTTP_X_TX_SIGNATURE'
+    TRANSIFEX_HEADER = 'X-TX-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)
+        digest(transform(content), secret)
+      end
+
+      private
+
+      # In order to generate a correct HMAC hash, the request body must be
+      # parsed and made to look like a python map. If you're thinking that's
+      # weird, you're correct, but it's apparently expected behavior.
+      def transform(content)
+        params = URI.decode_www_form(content)
+
+        params = params.map do |key, val|
+          key = "'#{key}'"
+          val = interpret_val(val)
+          "#{key}: #{val}"
+        end
+
+        "{#{params.join(', ')}}"
+      end
+
+      def interpret_val(val)
+        if val =~ /\A[\d]+\z/
+          val
+        else
+          "u'#{val}'"
+        end
+      end
+
+      def digest(content, secret)
+        Base64.encode64(
+          OpenSSL::HMAC.digest(HMAC_DIGEST, secret, content)
+        ).strip
+      end
+    end
+  end
+end

data/lib/txgh/tx_branch_resource.rb

@@ -0,0 +1,59 @@
+require 'forwardable'
+
+module Txgh
+  class TxBranchResource
+    extend Forwardable
+
+    def_delegators :@resource, *[
+      :project_slug, :type, :source_lang, :source_file, :L10N_resource_slug,
+      :translation_file, :lang_map, :translation_path, :original_resource_slug,
+      :to_h, :to_api_h
+    ]
+
+    attr_reader :resource, :branch
+
+    class << self
+      def find(tx_config, resource_slug, branch)
+        resource_slug = deslugify(resource_slug, branch)
+        resource = tx_config.resource(resource_slug)
+        new(resource, branch) if resource
+      end
+
+      def deslugify(resource_slug, branch)
+        suffix = "-#{Utils.slugify(branch)}"
+
+        if resource_slug.end_with?(suffix)
+          resource_slug.chomp(suffix)
+        else
+          resource_slug
+        end
+      end
+    end
+
+    def initialize(resource, branch)
+      @resource = resource
+      @branch = branch
+    end
+
+    def resource_slug
+      "#{resource.resource_slug}-#{slugified_branch}"
+    end
+
+    def slugs
+      [project_slug, resource_slug]
+    end
+
+    def to_h
+      resource.to_h.merge(
+        project_slug: project_slug,
+        resource_slug: resource_slug
+      )
+    end
+
+    private
+
+    def slugified_branch
+      Utils.slugify(branch)
+    end
+  end
+end