txgh 5.3.4 → 5.4.0

data/lib/txgh/handlers/download_handler.rb

@@ -1,87 +0,0 @@
-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'], languages: project.languages
-        )
-
-        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/delete_handler.rb

@@ -1,65 +0,0 @@
-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_resource(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

@@ -1,20 +0,0 @@
-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

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

@@ -1,18 +0,0 @@
-module Txgh
-  module Handlers
-    module Github
-      # Handles github's ping event, which is a test event fired whenever a new
-      # webhook is set up.
-      class PingHandler
-        include ResponseHelpers
-
-        def initialize(options = {})
-        end
-
-        def execute
-          respond_with(200, {})
-        end
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-require 'base64'
-require 'set'
-
-module Txgh
-  module Handlers
-    module Github
-      class PushHandler < Handler
-
-        def execute
-          # Check if the branch in the hook data is the configured branch we want
-          logger.info("request github branch: #{branch}")
-          logger.info("config github branch: #{repo.github_config_branch}")
-
-          if should_process?
-            logger.info('found branch in github request')
-
-            tx_resources = tx_resources_for(branch)
-
-            modified_resources = added_and_modified_resources_for(tx_resources)
-            modified_resources += l10n_resources_for(tx_resources)
-
-            if repo.github_config_branch.include?('tags/')
-              modified_resources += tag_resources_for(tx_resources)
-            end
-
-            # Handle DBZ 'L10N' special case
-            if branch.include?("L10N")
-              logger.info('processing L10N tag')
-
-              # Create a new branch off tag commit
-              if branch.include?('tags/L10N')
-                repo.api.create_ref(repo.name, 'heads/L10N', payload['head_commit']['id'])
-              end
-            end
-
-            updater = ResourceUpdater.new(project, repo, logger)
-            categories = { 'author' => payload['head_commit']['committer']['name'] }
-            ref = repo.api.get_ref(repo.name, branch)
-
-            modified_resources.each do |resource|
-              updater.update_resource(resource, ref[:object][:sha], categories)
-            end
-          end
-
-          respond_with(200, true)
-        end
-
-        private
-
-        def tag_resources_for(tx_resources)
-          payload['head_commit']['modified'].each_with_object(Set.new) do |modified, ret|
-            logger.info("processing modified file: #{modified}")
-
-            if tx_resources.include?(modified)
-              ret << tx_resources[modified]
-            end
-          end
-        end
-
-        def l10n_resources_for(tx_resources)
-          payload['head_commit']['modified'].each_with_object(Set.new) do |modified, ret|
-            if tx_resources.include?(modified)
-              logger.info("setting new resource: #{tx_resources[modified].L10N_resource_slug}")
-              ret << tx_resources[modified]
-            end
-          end
-        end
-
-        # finds the resources that were updated in each commit
-        def added_and_modified_resources_for(tx_resources)
-          payload['commits'].each_with_object(Set.new) do |commit, ret|
-            logger.info('processing commit')
-
-            (commit['modified'] + commit['added']).each do |file|
-              logger.info("processing added/modified file: #{file}")
-
-              if tx_resources.include?(file)
-                ret << tx_resources[file]
-              end
-            end
-          end
-        end
-
-        # Build an index of known Tx resources, by source file
-        def tx_resources_for(branch)
-          tx_config.resources.each_with_object({}) do |resource, ret|
-            logger.info('processing resource')
-
-            # If we're processing by branch, create a branch resource. Otherwise,
-            # use the original resource.
-            ret[resource.source_file] = if repo.process_all_branches?
-              TxBranchResource.new(resource, branch)  # maybe find instead?
-            else
-              resource
-            end
-          end
-        end
-
-        def tx_config
-          @tx_config ||= Txgh::Config::TxManager.tx_config(project, repo, branch)
-        end
-
-        def branch
-          @ref ||= payload['ref'].sub(/^refs\//, '')
-        end
-
-        def should_process?
-          should_process_branch? && should_process_commit?
-        end
-
-        def should_process_branch?
-          repo.should_process_ref?(branch)
-        end
-
-        def should_process_commit?
-          # return false if 'after' commit sha is all zeroes (indicates branch
-          # has been deleted)
-          !(payload.fetch('after', '') =~ /\A0+\z/)
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-require 'json'
-
-module Txgh
-  module Handlers
-    module Github
-      class RequestHandler
-        class << self
-
-          include ResponseHelpers
-
-          def handle_request(request, logger)
-            case request.env['HTTP_X_GITHUB_EVENT']
-              when 'push'
-                handle_push(request, logger)
-              when 'delete'
-                handle_delete(request, logger)
-              when 'ping'
-                handle_ping(request, logger)
-              else
-                handle_unexpected
-            end
-          end
-
-          private
-
-          def handle_push(request, logger)
-            klass = Txgh::Handlers::Github::PushHandler
-            new(request, logger).handle(klass)
-          end
-
-          def handle_delete(request, logger)
-            klass = Txgh::Handlers::Github::DeleteHandler
-            new(request, logger).handle(klass)
-          end
-
-          def handle_ping(request, logger)
-            klass = Txgh::Handlers::Github::PingHandler
-            new(request, logger).handle(klass)
-          end
-
-          def handle_unexpected
-            respond_with_error(400, 'Unexpected event type')
-          end
-
-        end
-
-        include ResponseHelpers
-
-        attr_reader :request, :logger
-
-        def initialize(request, logger)
-          @request = request
-          @logger = logger
-        end
-
-        def handle(klass)
-          handle_safely do
-            handler = klass.new(
-              project: config.transifex_project,
-              repo: config.github_repo,
-              payload: payload,
-              logger: logger
-            )
-
-            handler.execute
-          end
-        end
-
-        private
-
-        def handle_safely
-          if authentic_request?
-            yield
-          else
-            respond_with_error(401, 'Unauthorized')
-          end
-        rescue => e
-          respond_with_error(500, "Internal server error: #{e.message}", e)
-        end
-
-        def payload
-          @payload ||= if request.params[:payload]
-            JSON.parse(request.params[:payload])
-          else
-            JSON.parse(request.body.read)
-          end
-        end
-
-        def github_repo_name
-          payload['repository']['full_name']
-        end
-
-        def config
-          @config ||= Txgh::Config::KeyManager.config_from_repo(github_repo_name)
-        end
-
-        def repo
-          config.github_repo
-        end
-
-        def authentic_request?
-          if repo.webhook_protected?
-            GithubRequestAuth.authentic_request?(
-              request, repo.webhook_secret
-            )
-          else
-            true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/txgh/handlers/github.rb

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

data/lib/txgh/handlers/response.rb

@@ -1,17 +0,0 @@
-module Txgh
-  module Handlers
-    class Response
-      attr_reader :status, :body, :error
-
-      def initialize(status, body, error = nil)
-        @status = status
-        @body = body
-        @error = error
-      end
-
-      def streaming?
-        false
-      end
-    end
-  end
-end

data/lib/txgh/handlers/stream_response.rb

@@ -1,39 +0,0 @@
-require 'mime/types'
-
-module Txgh
-  module Handlers
-    class StreamResponse
-      attr_reader :attachment, :enum
-
-      def initialize(attachment, enum)
-        @attachment = attachment
-        @enum = enum
-      end
-
-      def write_to(stream)
-        raise NotImplementedError,
-          "please implement #{__method__} in derived classes"
-      end
-
-      def file_extension
-        raise NotImplementedError,
-          "please implement #{__method__} in derived classes"
-      end
-
-      def headers
-        @headers ||= {
-          'Content-Disposition' => "attachment; filename=\"#{attachment}#{file_extension}\"",
-          'Content-Type' => MIME::Types.type_for(file_extension).first.content_type
-        }
-      end
-
-      def streaming?
-        true
-      end
-
-      def error
-        nil
-      end
-    end
-  end
-end

data/lib/txgh/handlers/tgz_stream_response.rb

@@ -1,41 +0,0 @@
-require 'rubygems/package'
-require 'stringio'
-require 'zlib'
-
-module Txgh
-  module Handlers
-    class TgzStreamResponse < StreamResponse
-      PERMISSIONS = 0644
-
-      def write_to(stream)
-        Zlib::GzipWriter.wrap(stream) do |gz|
-          pipe = StringIO.new('', 'wb')
-          tar = Gem::Package::TarWriter.new(pipe)
-
-          enum.each do |file_name, contents|
-            tar.add_file(file_name, PERMISSIONS) do |f|
-              f.write(contents)
-            end
-
-            flush(tar, pipe, gz)
-            stream.flush
-          end
-
-          flush(tar, pipe, gz)
-        end
-      end
-
-      def file_extension
-        '.tgz'
-      end
-
-      private
-
-      def flush(tar, pipe, gz)
-        tar.flush
-        gz.write(pipe.string)
-        pipe.reopen('')
-      end
-    end
-  end
-end

data/lib/txgh/handlers/transifex/hook_handler.rb

@@ -1,94 +0,0 @@
-require 'logger'
-
-module Txgh
-  module Handlers
-    module Transifex
-      class HookHandler
-        include CategorySupport
-        include ResponseHelpers
-
-        attr_reader :project, :repo, :resource_slug, :language, :logger
-
-        def initialize(options = {})
-          @project = options.fetch(:project)
-          @repo = options.fetch(:repo)
-          @resource_slug = options.fetch(:resource_slug)
-          @language = options.fetch(:language)
-          @logger = options.fetch(:logger) { Logger.new(STDOUT) }
-        end
-
-        def execute
-          logger.info(resource_slug)
-
-          check_error_response || begin
-            committer = ResourceCommitter.new(project, repo, logger)
-            committer.commit_resource(tx_resource, branch, language)
-            respond_with(200, true)
-          end
-        end
-
-        private
-
-        def check_error_response
-          check_supported_language || check_tx_config || check_tx_resource
-        end
-
-        def check_supported_language
-          respond_with(304, true) unless supported_language?
-        end
-
-        def check_tx_config
-          unless tx_config
-            respond_with_error(
-              404, "Could not find configuration for branch '#{branch}'"
-            )
-          end
-        end
-
-        def check_tx_resource
-          unless tx_resource
-            respond_with_error(
-              404, "Could not find resource '#{resource_slug}' in config"
-            )
-          end
-        end
-
-        def tx_config
-          @tx_config ||= Txgh::Config::TxManager.tx_config(project, repo, branch)
-        rescue ConfigNotFoundError, TxghError
-          nil
-        end
-
-        def branch
-          @branch ||= begin
-            branch_candidate = if process_all_branches?
-              resource = project.api.get_resource(project.name, resource_slug)
-              categories = deserialize_categories(Array(resource['categories']))
-              categories['branch']
-            else
-              repo.branch || 'master'
-            end
-
-            Utils.absolute_branch(branch_candidate)
-          end
-        end
-
-        def tx_resource
-          @tx_resource ||= if process_all_branches?
-            tx_config.resource(resource_slug, branch)
-          else
-            tx_config.resource(resource_slug)
-          end
-        end
-
-        def process_all_branches?
-          repo.process_all_branches?
-        end
-
-        def supported_language?
-          project.supported_language?(language)
-        end
-      end
-    end
-  end
-end