txgh 1.0.0

data/lib/txgh/category_support.rb

@@ -0,0 +1,31 @@
+module Txgh
+  module CategorySupport
+    def deserialize_categories(categories_arr)
+      categories_arr.each_with_object({}) do |category_str, ret|
+        category_str.split(' ').each do |category|
+          if idx = category.index(':')
+            ret[category[0...idx]] = category[(idx + 1)..-1]
+          end
+        end
+      end
+    end
+
+    def serialize_categories(categories_hash)
+      categories_hash.map do |key, value|
+        "#{key}:#{escape_category(value)}"
+      end
+    end
+
+    def escape_category(str)
+      str.gsub(' ', '_')
+    end
+
+    def join_categories(arr)
+      arr.join(' ')
+    end
+  end
+
+  # add all the methods as class methods (they're also available as instance
+  # methods for anyone who includes this module)
+  CategorySupport.extend(CategorySupport)
+end

data/lib/txgh/config.rb

@@ -0,0 +1,11 @@
+module Txgh
+  module Config
+    autoload :ConfigPair,       'txgh/config/config_pair'
+    autoload :KeyManager,       'txgh/config/key_manager'
+    autoload :ProviderInstance, 'txgh/config/provider_instance'
+    autoload :Providers,        'txgh/config/providers'
+    autoload :ProviderSupport,  'txgh/config/provider_support'
+    autoload :TxConfig,         'txgh/config/tx_config'
+    autoload :TxManager,        'txgh/config/tx_manager'
+  end
+end

data/lib/txgh/config/config_pair.rb

@@ -0,0 +1,36 @@
+module Txgh
+  module Config
+    class ConfigPair
+      attr_reader :project_config, :repo_config
+
+      def initialize(project_config, repo_config)
+        @project_config = project_config
+        @repo_config = repo_config
+      end
+
+      def github_repo
+        @github_repo ||= Txgh::GithubRepo.new(
+          repo_config, github_api
+        )
+      end
+
+      def transifex_project
+        @transifex_project ||= Txgh::TransifexProject.new(
+          project_config, transifex_api
+        )
+      end
+
+      def transifex_api
+        @transifex_api ||= Txgh::TransifexApi.create_from_credentials(
+          project_config['api_username'], project_config['api_password']
+        )
+      end
+
+      def github_api
+        @github_api ||= Txgh::GithubApi.create_from_credentials(
+          repo_config['api_username'], repo_config['api_token']
+        )
+      end
+    end
+  end
+end

data/lib/txgh/config/key_manager.rb

@@ -0,0 +1,54 @@
+require 'erb'
+require 'etc'
+require 'yaml'
+
+module Txgh
+  module Config
+    class KeyManager
+      class << self
+        include ProviderSupport
+
+        def config_from_project(project_name)
+          project_config = project_config_for(project_name)
+          repo_config = repo_config_for(project_config['push_translations_to'])
+          ConfigPair.new(project_config, repo_config)
+        end
+
+        def config_from_repo(repo_name)
+          repo_config = repo_config_for(repo_name)
+          project_config = project_config_for(repo_config['push_source_to'])
+          ConfigPair.new(project_config, repo_config)
+        end
+
+        def config_from(project_name, repo_name)
+          project_config = project_config_for(project_name)
+          repo_config = repo_config_for(repo_name)
+          ConfigPair.new(project_config, repo_config)
+        end
+
+        private
+
+        def raw_config
+          ENV['TXGH_CONFIG']
+        end
+
+        def base_config
+          scheme, payload = split_uri(raw_config)
+          provider_for(scheme).load(payload)
+        end
+
+        def project_config_for(project_name)
+          if config = base_config['transifex']['projects'][project_name]
+            config.merge('name' => project_name)
+          end
+        end
+
+        def repo_config_for(repo_name)
+          if config = base_config['github']['repos'][repo_name]
+            config.merge('name' => repo_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/txgh/config/provider_instance.rb

@@ -0,0 +1,20 @@
+module Txgh
+  module Config
+    class ProviderInstance
+      attr_reader :provider, :parser
+
+      def initialize(provider, parser)
+        @provider = provider
+        @parser = parser
+      end
+
+      def supports?(*args)
+        provider.supports?(*args)
+      end
+
+      def load(payload, options = {})
+        provider.load(payload, parser, options)
+      end
+    end
+  end
+end

data/lib/txgh/config/provider_support.rb

@@ -0,0 +1,26 @@
+module Txgh
+  module Config
+    module ProviderSupport
+      def register_provider(provider, parser)
+        providers << ProviderInstance.new(provider, parser)
+      end
+
+      def providers
+        @providers ||= []
+      end
+
+      def provider_for(scheme)
+        providers.find { |provider| provider.supports?(scheme) }
+      end
+
+      def split_uri(uri)
+        if uri =~ /\A[\w]+:\/\//
+          idx = uri.index('://')
+          [uri[0...idx], uri[(idx + 3)..-1]]
+        else
+          [nil, uri]
+        end
+      end
+    end
+  end
+end

data/lib/txgh/config/providers.rb

@@ -0,0 +1,9 @@
+module Txgh
+  module Config
+    module Providers
+      autoload :FileProvider, 'txgh/config/providers/file_provider'
+      autoload :GitProvider,  'txgh/config/providers/git_provider'
+      autoload :RawProvider,  'txgh/config/providers/raw_provider'
+    end
+  end
+end

data/lib/txgh/config/providers/file_provider.rb

@@ -0,0 +1,19 @@
+module Txgh
+  module Config
+    module Providers
+      class FileProvider
+        SCHEME = 'file'
+
+        class << self
+          def supports?(scheme)
+            scheme == SCHEME
+          end
+
+          def load(payload, parser, options = {})
+            parser.load_file(payload)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/txgh/config/providers/git_provider.rb

@@ -0,0 +1,58 @@
+module Txgh
+  module Config
+    module Providers
+      class GitProvider
+        SCHEME = 'git'
+
+        class << self
+          def supports?(scheme)
+            scheme == SCHEME
+          end
+
+          def load(payload, parser, options = {})
+            new(payload, parser, options).config
+          end
+        end
+
+        attr_reader :payload, :parser
+
+        def initialize(payload, parser, options = {})
+          @payload = payload
+          @parser = parser
+          @ref = options[:ref]
+          @github_repo = options[:github_repo]
+        end
+
+        def config
+          parser.load(download)
+        end
+
+        private
+
+        def download
+          github_repo.api.download(github_repo.name, payload, ref)
+        rescue Octokit::NotFound
+          raise ConfigNotFoundError, "Config file #{payload} not found in #{ref}"
+        end
+
+        def ref
+          unless @ref
+            raise TxghError,
+              "TX_CONFIG specified a file from git but did not provide a ref."
+          end
+
+          @ref
+        end
+
+        def github_repo
+          unless @github_repo
+            raise TxghError,
+              "TX_CONFIG specified a file from git but did not provide a repo."
+          end
+
+          @github_repo
+        end
+      end
+    end
+  end
+end

data/lib/txgh/config/providers/raw_provider.rb

@@ -0,0 +1,19 @@
+module Txgh
+  module Config
+    module Providers
+      class RawProvider
+        SCHEME = 'raw'
+
+        class << self
+          def supports?(scheme)
+            scheme == SCHEME
+          end
+
+          def load(payload, parser, options = {})
+            parser.load(payload)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/txgh/config/tx_config.rb

@@ -0,0 +1,77 @@
+module Txgh
+  module Config
+    class TxConfig
+      class << self
+        def load_file(path)
+          config = Txgh::ParseConfig.load_file(path)
+          parse(config)
+        end
+
+        def load(contents)
+          config = Txgh::ParseConfig.load(contents)
+          parse(config)
+        end
+
+        private
+
+        def parse(config)
+          resources = []
+          lang_map = {}
+
+          config.get_groups.each do |group|
+            if group == 'main'
+              main = config[group]
+
+              if main['lang_map']
+                lang_map = parse_lang_map(main['lang_map'])
+              end
+            else
+              resources.push(
+                parse_resource(group, config[group])
+              )
+            end
+          end
+
+          new(resources, lang_map)
+        end
+
+        def parse_lang_map(lang_map)
+          lang_map.split(',').each_with_object({}) do |m, result|
+            key_value = m.split(':', 2)
+            result[key_value[0].strip] = key_value[1].strip
+          end
+        end
+
+        def parse_resource(name, resource)
+          id = name.split('.', 2)
+          TxResource.new(
+            id[0].strip, id[1].strip, resource['type'],
+            resource['source_lang'], resource['source_file'],
+            resource['lang_map'], resource['file_filter']
+          )
+        end
+      end
+
+      attr_reader :resources, :lang_map
+
+      def initialize(resources, lang_map)
+        @resources = resources
+        @lang_map = lang_map
+      end
+
+      def resource(slug, branch = nil)
+        if branch
+          TxBranchResource.find(self, slug, branch)
+        else
+          resources.find do |resource|
+            resource.resource_slug == slug
+          end
+        end
+      end
+
+      def to_h
+        { resources: resources.map(&:to_h), lang_map: lang_map }
+      end
+    end
+  end
+end

data/lib/txgh/config/tx_manager.rb

@@ -0,0 +1,15 @@
+module Txgh
+  module Config
+    class TxManager
+      class << self
+        include ProviderSupport
+
+        def tx_config(transifex_project, github_repo, ref = nil)
+          options = { github_repo: github_repo, ref: ref }
+          scheme, payload = split_uri(transifex_project.tx_config_uri)
+          provider_for(scheme).load(payload, options)
+        end
+      end
+    end
+  end
+end

data/lib/txgh/diff_calculator.rb

@@ -0,0 +1,90 @@
+module Txgh
+  class DiffCalculator
+    class << self
+      def compare(head_phrases, diff_point_phrases)
+        new(head_phrases, diff_point_phrases).compare
+      end
+    end
+
+    INCLUDED_STATES = [:added, :modified, :removed]
+
+    attr_reader :head_phrases, :diff_point_phrases
+
+    def initialize(head_phrases, diff_point_phrases)
+      @head_phrases = head_phrases
+      @diff_point_phrases = diff_point_phrases
+    end
+
+    def compare
+      join_diffs(compare_head, compare_diff_point)
+    end
+
+    private
+
+    def join_diffs(diff1, diff2)
+      INCLUDED_STATES.each_with_object({}) do |state, ret|
+        ret[state] = diff1[state] + diff2[state]
+      end
+    end
+
+    def compare_head
+      compare_enum(head_to_diff_point)
+    end
+
+    def compare_diff_point
+      compare_enum(diff_point_to_head)
+    end
+
+    def compare_enum(enum)
+      enum.each_with_object(new_hash_of_arrays) do |(phrase, state), diff|
+        diff[state] << phrase
+      end
+    end
+
+    # identifies phrases in head that:
+    #   are not in diff point ('added')
+    #   have the same key but different strings diff point ('modified')
+    #   are identical to a phrase in diff point ('unmodified'), but
+    #     does not yield them
+    def head_to_diff_point
+      return to_enum(__method__) unless block_given?
+
+      # iterate over all head phrases that have keys
+      head_phrases.each do |head_phrase|
+        idx = diff_point_phrases.find_index do |diff_point_phrase|
+          diff_point_phrase['key'] == head_phrase['key']
+        end
+
+        state = compare_at(idx, head_phrase)
+        yield(head_phrase, state) if INCLUDED_STATES.include?(state)
+      end
+    end
+
+    def compare_at(idx, head_phrase)
+      return :added unless idx
+
+      if diff_point_phrases[idx]['string'] == head_phrase['string']
+        :unmodified
+      else
+        :modified
+      end
+    end
+
+    # identifies phrases in diff point that are not in head ('removed')
+    def diff_point_to_head
+      return to_enum(__method__) unless block_given?
+
+      diff_point_phrases.each do |diff_point_phrase|
+        idx = head_phrases.find_index do |head_phrase|
+          head_phrase['key'] == diff_point_phrase['key']
+        end
+
+        yield(diff_point_phrase, :removed) unless idx
+      end
+    end
+
+    def new_hash_of_arrays
+      Hash.new { |hash, key| hash[key] = [] }
+    end
+  end
+end