rosette-core 1.0.1

data/lib/rosette/data_stores/phrase_status.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+module Rosette
+  module DataStores
+
+    # Contains several constants indicating the translation status of a set
+    # of phrases. Generally attached to commit logs.
+    module PhraseStatus
+      # The commit has not even been seen yet, i.e. this is the first time
+      # Rosette has ever encountered it.
+      NOT_SEEN = 'NOT_SEEN'
+
+      # The repository that contains this commit has been fetched in preparation
+      # for processing it.
+      FETCHED = 'FETCHED'
+
+      # Indicates the phrases have been extracted from the commit.
+      EXTRACTED = 'EXTRACTED'
+
+      # The extracted phrases have been submitted for translation.
+      PUSHED = 'PUSHED'
+
+      # The commit has been completely processed.
+      FINALIZED = 'FINALIZED'
+
+      # Indicates that the commit no longer exists, i.e. the associated branch
+      # was deleted or was force-pushed over.
+      MISSING = 'MISSING'
+
+      # Indicates one or all of the commits have not been processed.
+      NOT_FOUND = 'NOT_FOUND'
+
+      def self.all
+        @all ||= [
+          NOT_SEEN, FETCHED, EXTRACTED, PUSHED, FINALIZED, MISSING, NOT_FOUND
+        ]
+      end
+
+      def self.statuses
+        @statuses ||= [
+          NOT_SEEN, FETCHED, EXTRACTED, PUSHED, FINALIZED
+        ]
+      end
+
+      def self.incomplete
+        @incomplete ||= [
+          NOT_SEEN, FETCHED, EXTRACTED, PUSHED, NOT_FOUND
+        ]
+      end
+
+      def self.index(status)
+        (@status_index ||= {}).fetch(status) do
+          statuses.index(status)
+        end
+      end
+    end
+
+  end
+end

data/lib/rosette/integrations.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+module Rosette
+
+  # Base classes and other scaffolding for Rosette's integrations.
+  module Integrations
+    autoload :Errors,           'rosette/integrations/errors'
+    autoload :Integration,      'rosette/integrations/integration'
+    autoload :Integratable,     'rosette/integrations/integratable'
+  end
+
+end

data/lib/rosette/integrations/errors.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module Rosette
+  module Integrations
+
+    # Errors that can be raised during integration operations.
+    module Errors
+      # Raised whenever an integration is deemed impossible. Impossible
+      # integrations happen when Rosette can't determine how an integration
+      # should be applied to the system.
+      class ImpossibleIntegrationError < StandardError; end
+    end
+
+  end
+end

data/lib/rosette/integrations/integratable.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+module Rosette
+  module Integrations
+
+    # Intended to be mixed in to classes that can be integrated with. Provides
+    # methods to add and retrieve integration configs as well as apply
+    # configured integrations to the parent.
+    module Integratable
+      # Returns the current list of integration configs.
+      #
+      # @return [Array]
+      def integrations
+        @integrations ||= []
+      end
+
+      # Add an integration. Yields an instance of the integration's
+      # configurator object to the given block.
+      #
+      # @param [String] integration_id The id of the integration to add.
+      # @yield [config]
+      # @yieldparam config The integration's configurator.
+      # @return [void]
+      def add_integration(integration_id, &block)
+        klass = Rosette::Core::IntegrationId.resolve(integration_id)
+        integrations << klass.configure(&block)
+      end
+
+      # Retrieve the integration config by id.
+      #
+      # @param [String] integration_id The integration id.
+      # @return [nil, Object] The integration's configurator.
+      def get_integration(integration_id)
+        klass = Rosette::Core::IntegrationId.resolve(integration_id)
+
+        if klass
+          integrations.find do |integration|
+            integration.is_a?(klass)
+          end
+        end
+      rescue ArgumentError
+      end
+
+      # Applies the integrations to the given object.
+      #
+      # @param [Object] obj The object to apply the integrations to.
+      # @return [void]
+      def apply_integrations(obj)
+        integrations.each do |integration|
+          if integration.integrates_with?(obj)
+            integration.integrate(obj)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/rosette/integrations/integration.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Rosette
+  module Integrations
+
+    # The base class for all integrations.
+    #
+    # @!attribute [r] configuration
+    #   @return [Configurator] the Rosette config.
+    class Integration
+      attr_reader :configuration
+
+      # Creates a new integration instance.
+      #
+      # @param [Object] configuration an instance of this integration's
+      #   configurator.
+      def initialize(configuration)
+        @configuration = configuration
+      end
+    end
+
+  end
+end

data/lib/rosette/preprocessors.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module Rosette
+
+  # Namespace for all of Rosette's pre-processors.
+  module Preprocessors
+    autoload :Errors,       'rosette/preprocessors/errors'
+    autoload :Preprocessor, 'rosette/preprocessors/preprocessor'
+  end
+
+end

data/lib/rosette/preprocessors/errors.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module Rosette
+  module Preprocessors
+
+    # Errors that can be raised during pre-processing.
+    module Errors
+      # Raised if a preprocessor doesn't know how to process the object given
+      # to it.
+      class UnsupportedObjectError < StandardError; end
+    end
+
+  end
+end

data/lib/rosette/preprocessors/preprocessor.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+module Rosette
+  module Preprocessors
+
+    # Base class for all of Rosette's pre-processors.
+    #
+    # @!attribute [r] configuration
+    #   @return [Object] an instance of this pre-processor's configurator.
+    class Preprocessor
+      attr_reader :configuration
+
+      # Creates a new pre-processor.
+      #
+      # @param [Object] configuration An instance of this pre-processor's
+      #   configurator.
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      # Processes the given object.
+      #
+      # @param [Object] object The object to process.
+      # @return [Object] A copy of +object+, modified as per this
+      #   pre-processor's functionality. If the object can be processed
+      #   but doesn't need to be, the original object is returned without
+      #   modifications.
+      # @raise [UnsupportedObjectError] Raised if the object is not
+      #   processable.
+      def process(object)
+        should_process = !configuration.applies_to_proc ||
+          configuration.applies_to_proc.call(object)
+
+        if should_process
+          if method = method_for(object)
+            send(method, object)
+          else
+            raise Rosette::Preprocessors::Errors::UnsupportedObjectError,
+              "don't know how to preprocess a(n) #{object.class.name}"
+          end
+        else
+          object
+        end
+      end
+    end
+
+  end
+end

data/lib/rosette/queuing.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module Rosette
+  module Queuing
+
+    autoload :QueueConfigurator, 'rosette/queuing/queue_configurator'
+    autoload :Job,               'rosette/queuing/job'
+    autoload :Queue,             'rosette/queuing/queue'
+    autoload :Worker,            'rosette/queuing/worker'
+
+    autoload :Commits,           'rosette/queuing/commits'
+
+  end
+end

data/lib/rosette/queuing/commits.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Rosette
+  module Queuing
+    module Commits
+
+      autoload :CommitJob,                'rosette/queuing/commits/commit_job'
+      autoload :CommitConductor,          'rosette/queuing/commits/commit_conductor'
+      autoload :CommitsQueueConfigurator, 'rosette/queuing/commits/commits_queue_configurator'
+      autoload :ExtractStage,             'rosette/queuing/commits/extract_stage'
+      autoload :FetchStage,               'rosette/queuing/commits/fetch_stage'
+      autoload :FinalizeStage,            'rosette/queuing/commits/finalize_stage'
+      autoload :PhraseStorageGranularity, 'rosette/queuing/commits/phrase_storage_granularity'
+      autoload :PushStage,                'rosette/queuing/commits/push_stage'
+      autoload :Stage,                    'rosette/queuing/commits/stage'
+
+    end
+  end
+end

data/lib/rosette/queuing/commits/commit_conductor.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+
+module Rosette
+  module Queuing
+    module Commits
+
+      # Coordinates moving a commit through a number of processing stages.
+      #
+      # @!attribute [r] rosette_config
+      #   @return [Configurator] the Rosette config to use.
+      # @!attribute [r] repo_name
+      #   @return [String] the name of the repo to process commits for.
+      # @!attribute [r] logger
+      #   @return [Logger] the logger to use.
+      # @return [void]
+      class CommitConductor
+        # The status that indicates a commit is completely processed, i.e. has
+        # no more stages to pass through.
+        FINISHED_STATUS = Rosette::DataStores::PhraseStatus::FINALIZED
+
+        attr_reader :rosette_config, :repo_name, :logger
+
+        def self.stage_classes
+          # grab all classes that inherit from Stage
+          @stage_classes ||= begin
+            namespace = Rosette::Queuing::Commits
+            namespace.constants
+              .map { |const_sym| namespace.const_get(const_sym) }
+              .select { |const| const < namespace::Stage }
+          end
+        end
+
+        # Creates a new instance of +CommitConductor
+        # @param [Configurator] rosette_config The Rosette config to use.
+        # @param [String] repo_name The name of the repo to process commits for.
+        # @param [Logger] logger The logger to use.
+        # @return [CommitConductor]
+        def initialize(rosette_config, repo_name, logger)
+          @rosette_config = rosette_config
+          @repo_name = repo_name
+          @logger = logger
+        end
+
+        # Creates a new job for the commit and enqueues it on the configured
+        # Rosette queue.
+        #
+        # @param [String] commit_id The commit to enqueue.
+        # @return [void]
+        def enqueue(commit_id)
+          job = CommitJob.new(repo_name, commit_id)
+          enqueue_job(job)
+        end
+
+        # Executes the current stage of the commit log and advances it to the
+        # next. Also updates the commit log's status.
+        #
+        # @param [CommitLog] commit_log The commit log to advance.
+        # @return [void]
+        def advance(commit_log)
+          create_stage_instance(commit_log).tap do |stage|
+            return unless stage
+            stage.execute!
+            return if finished?(stage)
+            enqueue_job(stage.to_job)
+          end
+        end
+
+        protected
+
+        def finished?(stage)
+          stage.commit_log.status == FINISHED_STATUS
+        end
+
+        def enqueue_job(job)
+          rosette_config.queue.enqueue(job)
+        end
+
+        def create_stage_instance(commit_log)
+          self.class.stage_classes.each do |stage_class|
+            if stage = stage_class.for_commit_log(commit_log, rosette_config, logger)
+              return stage
+            end
+          end
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/queuing/commits/commit_job.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+
+module Rosette
+  module Queuing
+    module Commits
+
+      # Encapsulates processing a commit at a specific stage in the process.
+      #
+      # @!attribute [r] repo_name
+      #   @return [String] the name of the repo the commit belongs to.
+      # @!attribute [r] commit_id
+      #   @return [String] the commit id to process.
+      # @!attribute [r] status
+      #   @return [String] the current status of the commit (mostly for display
+      #     and tracking purposes).
+      class CommitJob < Job
+        attr_reader :repo_name, :commit_id, :status
+
+        set_queue_name 'commits'
+
+        # Creates a new [CommitJob] object from a [Stage].
+        #
+        # @param [Stage] stage The stage to get parameters from.
+        # @return [CommitJob]
+        def self.from_stage(stage)
+          new(
+            stage.repo_config.name,
+            stage.commit_log.commit_id,
+            stage.commit_log.status
+          )
+        end
+
+        # Creates a new instance of [CommitJob].
+        #
+        # @param [String] repo_name The name of the repo the commit belongs to.
+        # @param [String] commit_id The commit id to process.
+        # @param [String] status The current status of the commit (mostly for
+        #   display and tracking purposes).
+        # @return [CommitJob]
+        def initialize(repo_name, commit_id, status = nil)
+          @repo_name = repo_name
+          @commit_id = commit_id
+          @status = status
+        end
+
+        # Converts this job into a list of arguments that should be able to be
+        # easily serialized for placement into a queue. These should be the
+        # same values the constructor accepts, since +CommitJob+s will be
+        # re-instantiated with these arguments when executed.
+        #
+        # @return [Array]
+        def to_args
+          [repo_name, commit_id, status]
+        end
+
+        # Fetches the commit log, instantiates a new [CommitConductor] and
+        # advances the commit to the next stage. If the commit log does not
+        # exist in the database, one will be created.
+        #
+        # @param [Configurator] rosette_config
+        # @param [Logger] logger
+        # @return [void]
+        def work(rosette_config, logger)
+          commit_log = find_or_create_commit_log(rosette_config)
+          conductor = CommitConductor.new(rosette_config, repo_name, logger)
+          conductor.advance(commit_log)
+        end
+
+        protected
+
+        def find_or_create_commit_log(rosette_config)
+          # god this is cumbersome... the datastore could really use a refactor
+          if commit_log = lookup_commit_log(rosette_config)
+            commit_log
+          else
+            rosette_config.datastore.add_or_update_commit_log(
+              repo_name, commit_id, nil, Rosette::DataStores::PhraseStatus::NOT_SEEN
+            )
+
+            lookup_commit_log(rosette_config)
+          end
+        end
+
+        def lookup_commit_log(rosette_config)
+          rosette_config.datastore.lookup_commit_log(
+            repo_name, commit_id
+          )
+        end
+      end
+
+    end
+  end
+end