txgh 1.0.0

data/lib/txgh/handlers/triggers.rb

@@ -0,0 +1,9 @@
+module Txgh
+  module Handlers
+    module Triggers
+      autoload :Handler,     'txgh/handlers/triggers/handler'
+      autoload :PullHandler, 'txgh/handlers/triggers/pull_handler'
+      autoload :PushHandler, 'txgh/handlers/triggers/push_handler'
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Txgh
+  module Handlers
+    module Triggers
+      class Handler
+
+        # includes response helpers in both the class and the singleton class
+        include ResponseHelpers
+
+        class << self
+          def handle_request(request, logger)
+            handle_safely do
+              config = Txgh::Config::KeyManager.config_from_project(
+                request.params.fetch('project_slug')
+              )
+
+              handler_for(config, request, logger).execute
+            end
+          end
+
+          private
+
+          def handle_safely
+            yield
+          rescue => e
+            respond_with_error(500, "Internal server error: #{e.message}", e)
+          end
+
+          def handler_for(config, request, logger)
+            new(
+              project: config.transifex_project,
+              repo: config.github_repo,
+              branch: request.params.fetch('branch'),
+              resource_slug: request.params.fetch('resource_slug'),
+              logger: logger
+            )
+          end
+        end
+
+        attr_reader :project, :repo, :branch, :resource_slug, :logger
+
+        def initialize(options = {})
+          @project = options[:project]
+          @repo = options[:repo]
+          @branch = Utils.absolute_branch(options[:branch])
+          @resource_slug = options[:resource_slug]
+          @logger = options[:logger]
+        end
+
+        private
+
+        def branch_resource
+          @branch_resource ||= TxBranchResource.new(resource, branch)
+        end
+
+        def resource
+          @resource ||= tx_config.resource(resource_slug)
+        end
+
+        def tx_config
+          @tx_config ||= Txgh::Config::TxManager.tx_config(project, repo, branch)
+        end
+
+      end
+    end
+  end
+end

data/lib/txgh/handlers/triggers/pull_handler.rb

@@ -0,0 +1,29 @@
+module Txgh
+  module Handlers
+    module Triggers
+      class PullHandler < Handler
+
+        def execute
+          languages.each do |language|
+            committer.commit_resource(
+              branch_resource, branch, language['language_code']
+            )
+          end
+
+          respond_with(200, true)
+        end
+
+        private
+
+        def committer
+          @committer ||= Txgh::ResourceCommitter.new(project, repo, logger)
+        end
+
+        def languages
+          @languages ||= project.api.get_languages(project.name)
+        end
+
+      end
+    end
+  end
+end

data/lib/txgh/handlers/triggers/push_handler.rb

@@ -0,0 +1,21 @@
+module Txgh
+  module Handlers
+    module Triggers
+      class PushHandler < Handler
+
+        def execute
+          ref = repo.api.get_ref(repo.name, branch)
+          updater.update_resource(branch_resource, ref[:object][:sha])
+          respond_with(200, true)
+        end
+
+        private
+
+        def updater
+          @updater ||= Txgh::ResourceUpdater.new(project, repo, logger)
+        end
+
+      end
+    end
+  end
+end

data/lib/txgh/handlers/zip_stream_response.rb

@@ -0,0 +1,21 @@
+require 'ext/zipline/output_stream'
+
+module Txgh
+  module Handlers
+    class ZipStreamResponse < StreamResponse
+
+      def write_to(stream)
+        Zipline::OutputStream.open(stream) do |zipfile|
+          enum.each do |file_name, contents|
+            zipfile.put_next_entry(file_name, contents.bytesize)
+            zipfile << contents
+          end
+        end
+      end
+
+      def file_extension
+        '.zip'
+      end
+    end
+  end
+end

data/lib/txgh/merge_calculator.rb

@@ -0,0 +1,74 @@
+module Txgh
+  class MergeCalculator
+    class << self
+      def merge(head_contents, diff_point_contents, diff_hash)
+        new(head_contents, diff_point_contents, diff_hash).merge
+      end
+    end
+
+    attr_reader :head_contents, :diff_point_contents, :diff_hash
+
+    # Merges are based on diffs. Whatever was added/removed/modified between
+    # two resources is represented by the diff, while the resources themselves
+    # are what gets merged. This class uses the given diff to apply one
+    # resource's phrases over the top of another.
+    #
+    # head_contents: translated contents in HEAD
+    # diff_point_contents: translated contents in diff point, eg. master
+    # diff_hash: what was added/removed/modified in the source
+    def initialize(head_contents, diff_point_contents, diff_hash)
+      @head_contents = head_contents
+      @diff_point_contents = diff_point_contents
+      @diff_hash = diff_hash
+    end
+
+    def merge
+      phrase_hash = diff_point_hash.dup
+      update_added(phrase_hash)
+      update_modified(phrase_hash)
+      update_removed(phrase_hash)
+
+      ResourceContents.from_phrase_list(
+        head_contents.tx_resource, phrase_hash.values
+      )
+    end
+
+    private
+
+    def update_added(phrase_hash)
+      diff.fetch(:added, {}).each_pair do |key, phrase|
+        if val = head_hash[key]
+          phrase_hash[key] = val
+        end
+      end
+    end
+
+    def update_modified(phrase_hash)
+      diff.fetch(:modified, {}).each_pair do |key, phrase|
+        if val = head_hash[key]
+          phrase_hash[key] = val
+        end
+      end
+    end
+
+    def update_removed(phrase_hash)
+      diff.fetch(:removed, {}).each_pair do |key, _|
+        phrase_hash.delete(key)
+      end
+    end
+
+    def diff
+      @diff ||= diff_hash.each_with_object({}) do |(status, phrases), ret|
+        ret[status] = Utils.index_on('key', phrases)
+      end
+    end
+
+    def head_hash
+      head_contents.to_h
+    end
+
+    def diff_point_hash
+      diff_point_contents.to_h
+    end
+  end
+end

data/lib/txgh/parse_config.rb

@@ -0,0 +1,24 @@
+require 'parseconfig'
+require 'tempfile'
+
+module Txgh
+  # This class wraps the ParseConfig class from the parseconfig gem and
+  # provides a way to load config from a string instead of just a file.
+  class ParseConfig < ::ParseConfig
+    class << self
+      def load(contents)
+        tmp = Tempfile.new('parseconfig')
+        tmp.write(contents)
+        tmp.close
+        load_file(tmp.path)
+      ensure
+        tmp.unlink if tmp
+      end
+
+      def load_file(path)
+        # use the default file loading logic
+        new(path)
+      end
+    end
+  end
+end

data/lib/txgh/resource_committer.rb

@@ -0,0 +1,39 @@
+module Txgh
+  class ResourceCommitter
+    attr_reader :project, :repo, :logger
+
+    def initialize(project, repo, logger = nil)
+      @project = project
+      @repo = repo
+      @logger = logger || Logger.new(STDOUT)
+    end
+
+    def commit_resource(tx_resource, branch, language)
+      return if prevent_commit_on?(branch)
+
+      unless language == tx_resource.source_lang
+        file_name, translations = download(tx_resource, branch, language)
+
+        if translations
+          repo.api.commit(repo.name, branch, { file_name => translations })
+        end
+      end
+    end
+
+    private
+
+    def download(tx_resource, branch, language)
+      downloader = ResourceDownloader.new(
+        project, repo, branch, {
+          languages: [language], resources: [tx_resource]
+        }
+      )
+
+      downloader.first
+    end
+
+    def prevent_commit_on?(branch)
+      project.protected_branches.include?(branch)
+    end
+  end
+end

data/lib/txgh/resource_contents.rb

@@ -0,0 +1,118 @@
+require 'abroad'
+require 'stringio'
+
+module Txgh
+  class ResourceContents
+    EXTRACTOR_MAP = {
+      'YML'          => 'yaml/rails',
+      'YAML'         => 'yaml/rails',
+      'KEYVALUEJSON' => 'json/key-value',
+      'ANDROID'      => 'xml/android'
+    }
+
+    SERIALIZER_MAP = {
+      'YML'          => 'yaml/rails',
+      'YAML'         => 'yaml/rails',
+      'KEYVALUEJSON' => 'json/key-value',
+      'ANDROID'      => 'xml/android'
+    }
+
+    class << self
+      def from_phrase_list(tx_resource, phrases)
+        new(tx_resource, phrases: phrases)
+      end
+
+      def from_string(tx_resource, string)
+        new(tx_resource, raw: string)
+      end
+    end
+
+    attr_reader :tx_resource
+
+    def initialize(tx_resource, options)
+      @tx_resource = tx_resource
+      @phrases = options[:phrases]
+      @raw = options[:raw]
+    end
+
+    def phrases
+      @phrases ||= extractor.from_string(raw) do |extractor|
+        extractor.extract_each.map do |key, value|
+          { 'key' => key, 'string' => value }
+        end
+      end
+    end
+
+    def add(key, value)
+      phrases << { 'key' => key, 'string' => value }
+    end
+
+    # Some formats like Rails YAML require the language to be written somewhere
+    # in the file. If you're using this class to parse and serialize the
+    # contents of a translated version of a resource, then you'll probably
+    # want to override the resource's source language using the second
+    # parameter here.
+    def write_to(stream, language = tx_resource.source_lang)
+      serializer.from_stream(stream, language) do |serializer|
+        phrases.each do |phrase|
+          serializer.write_key_value(
+            phrase['key'], (phrase['string'] || '').to_s
+          )
+        end
+      end
+    end
+
+    # see comment above write_to
+    def to_s(language = tx_resource.source_lang)
+      stream = StringIO.new
+      write_to(stream, language)
+      stream.string
+    end
+
+    def to_h
+      Utils.index_on('key', phrases)
+    end
+
+    def diff(other_contents)
+      diff = diff_hash(other_contents)
+      diff_phrases = diff[:added] + diff[:modified]
+      self.class.from_phrase_list(tx_resource, diff_phrases)
+    end
+
+    def diff_hash(other_contents)
+      DiffCalculator.compare(phrases, other_contents.phrases)
+    end
+
+    def merge(other_contents, diff_hash)
+      MergeCalculator.merge(other_contents, self, diff_hash)
+    end
+
+    def empty?
+      phrases.empty?
+    end
+
+    private
+
+    attr_reader :raw
+
+    def extractor
+      id = EXTRACTOR_MAP.fetch(tx_resource.type) do
+        raise TxghInternalError,
+          "'#{tx_resource.type}' is not a file type that is supported when "\
+          "uploading diffs."
+      end
+
+      Abroad.extractor(id)
+    end
+
+    def serializer
+      id = SERIALIZER_MAP.fetch(tx_resource.type) do
+        raise TxghInternalError,
+          "'#{tx_resource.type}' is not a file type that is supported when "\
+          "uploading diffs."
+      end
+
+      Abroad.serializer(id)
+    end
+  end
+end

data/lib/txgh/resource_downloader.rb

@@ -0,0 +1,141 @@
+module Txgh
+  class ResourceDownloader
+    include Enumerable
+
+    attr_reader :project, :repo, :branch
+
+    def initialize(project, repo, branch, options = {})
+      @project = project
+      @repo = repo
+      @branch = branch
+
+      # Provides an override list of languages. If not present, the downloader
+      # will make an API call to fetch the list of languages for the project.
+      @languages = options[:languages]
+      @resources = options[:resources]
+    end
+
+    def each(&block)
+      enum.each(&block)
+    end
+
+    private
+
+    def enum
+      if repo.upload_diffs?
+        download_merging_diff
+      else
+        download_without_diff
+      end
+    end
+
+    def download_merging_diff
+      return to_enum(__method__) unless block_given?
+
+      download_each do |head_resource, language_code, file_name|
+        diff_point_resource = tx_config.resource(
+          head_resource.original_resource_slug, repo.diff_point
+        )
+
+        source_diff = source_diff_hash(head_resource, diff_point_resource)
+        head_content = wrap(transifex_download(head_resource, language_code), head_resource)
+        diff_point_content = wrap(transifex_download(diff_point_resource, language_code), diff_point_resource)
+        contents = diff_point_content.merge(head_content, source_diff)
+
+        yield file_name, contents.to_s(language_code)
+      end
+    end
+
+    def source_diff_hash(head_resource, diff_point_resource)
+      cache_diff(head_resource, diff_point_resource) do
+        br = repo.process_all_branches? ? branch : repo.branch
+        head_contents = wrap(git_download(head_resource, br), head_resource)
+        diff_point_contents = wrap(git_download(diff_point_resource, repo.diff_point), head_resource)
+        head_contents.diff_hash(diff_point_contents)
+      end
+    end
+
+    def cache_diff(head_resource, diff_point_resource)
+      key = "#{head_resource.resource_slug}|#{diff_point_resource.resource_slug}"
+      if diff = diff_cache[key]
+        diff
+      else
+        diff_cache[key] = yield
+      end
+    end
+
+    def diff_cache
+      @diff_cache ||= {}
+    end
+
+    def download_without_diff
+      return to_enum(__method__) unless block_given?
+
+      download_each do |resource, language_code, file_name|
+        contents = transifex_download(resource, language_code)
+        yield file_name, contents
+      end
+    end
+
+    def download_each
+      each_resource do |resource|
+        each_language do |language_code|
+          file_name = resource.translation_path(resource.lang_map(language_code))
+          yield resource, language_code, file_name
+        end
+      end
+    end
+
+    def wrap(string, resource)
+      if string
+        ResourceContents.from_string(resource, string)
+      else
+        EmptyResourceContents.new(resource)
+      end
+    end
+
+    def transifex_download(resource, language)
+      transifex_api.download(resource, language)
+    rescue TransifexNotFoundError
+      nil
+    end
+
+    def git_download(resource, branch)
+      repo.api.download(repo.name, resource.source_file, branch)
+    end
+
+    def transifex_api
+      project.api
+    end
+
+    def each_resource(&block)
+      return to_enum(__method__) unless block_given?
+      return @resources.each(&block) if @resources
+
+      ref = repo.process_all_branches? ? branch : nil
+
+      tx_config.resources.each do |res|
+        yield tx_config.resource(res.resource_slug, ref)
+      end
+    end
+
+    def each_language(&block)
+      return to_enum(__method__) unless block_given?
+      return @languages.each(&block) if @languages
+
+      raw_languages.each(&block)
+    end
+
+    def raw_languages
+      @raw_languages ||= transifex_api.get_languages(project.name).map do |lang|
+        lang['language_code']
+      end
+    end
+
+    def tx_config
+      @tx_config ||= Txgh::Config::TxManager.tx_config(
+        project, repo, repo.process_all_branches? ? branch : repo.branch
+      )
+    end
+  end
+end