rosette-core 1.0.1

data/lib/rosette/core/commands/translations/translation_lookup_command.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Returns the translation for the given phrase and locale combination.
+      #
+      # @!attribute [r] locale
+      #   @return [String] the locale to export translations for.
+      #
+      # @example
+      #   cmd = TranslationLookupCommand.new(configuration)
+      #     .set_repo_name('my_repo')
+      #     .set_locale('es')
+      #     .set_meta_key('my.phrase')
+      #     .set_key('I am a phrase')
+      #
+      #   cmd.execute
+      #   # => "Soy una frase"
+      #
+      # @!attribute [r] locale
+      #   @return [String] the locale of the translation to look up.
+      # @!attribute [r] repo_name
+      #   @return [String] the name of the repo the phrase (and therefore the
+      #     translation) belongs to.
+      # @!attribute [r] key
+      #   @return [String] the phrase key.
+      # @!attribute [r] meta_key
+      #   @return [String] the phrase meta key.
+      class TranslationLookupCommand < GitCommand
+        attr_reader :key, :meta_key
+
+        include WithRepoName
+        include WithRef
+        include WithLocale
+
+        def set_key(key)
+          @key = key
+          self
+        end
+
+        def set_meta_key(meta_key)
+          @meta_key = meta_key
+          self
+        end
+
+        def execute
+          phrase = datastore.lookup_phrase(repo_name, key, meta_key, commit_id)
+          repo_config.tms.lookup_translation(locale_obj, phrase)
+        end
+
+        protected
+
+        def repo_config
+          configuration.get_repo(repo_name)
+        end
+
+        def locale_obj
+          repo_config.locales.find { |l| l.code == locale }
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/translations/with_locale.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Mixin that handles configuration and validation of a locale code.
+      # Meant to be mixed into the classes in {Rosette::Core::Commands}.
+      #
+      # @example
+      #   class MyCommand < Command
+      #     include WithRepoName
+      #     include WithLocale
+      #   end
+      #
+      #   cmd = MyCommand.new(configuration)
+      #     .set_repo_name('my_repo')
+      #     .set_locale('ja-JP')
+      #
+      #   cmd.locale    # => 'ja-JP'
+      #   cmd.valid?    # => true
+      #
+      #   cmd.set_locale('foobar')
+      #   cmd.valid?    # => false
+      #   cmd.messages  # => { locale: ["Repo 'my_repo' doesn't support the 'foobar' locale"] }
+      module WithLocale
+        attr_reader :locale
+
+        # Sets the locale code.
+        #
+        # @param [String] locale_code
+        # @return [self]
+        def set_locale(locale_code)
+          @locale = locale_code
+          self
+        end
+
+        protected
+
+        def self.included(base)
+          base.validate :locale, type: :locale
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/configurator.rb

@@ -0,0 +1,160 @@
+# encoding: UTF-8
+
+require 'active_support'
+require 'rosette/integrations'
+
+module Rosette
+  module Core
+
+    # Builds Rosette configuration. Usually used via +Rosette#build_config+.
+    #
+    # @see Rosette
+    #
+    # @example
+    #   config = Rosette.build_config do |config|
+    #     config.add_repo do |repo_config|
+    #       ...
+    #     end
+    #   end
+    #
+    # @!attribute [r] repo_configs
+    #   @return [Array<RepoConfig>] The current array of configured repo
+    #     configs.
+    # @!attribute [r] datastore
+    #   @return [DataStore] The datastore to store phrases and translations in.
+    # @!attribute [r] cache
+    #   @return [#fetch] The cache instance to use (can be +nil+).
+    # @!attribute [r] queue
+    #   @return [Rosette::Queuing::Queue] The queue implementation to use.
+    # @!attribute [r] error_reporter
+    #   @return [ErrorReporter] The error reporter to use if errors occur.
+    class Configurator
+      include Integrations::Integratable
+
+      attr_reader :repo_configs, :datastore, :cache, :queue, :error_reporter
+
+      # Creates a new config object.
+      def initialize
+        @repo_configs = []
+        @integrations = []
+        @cache = ActiveSupport::Cache.lookup_store
+        @error_reporter ||= PrintingErrorReporter.new(STDOUT)
+      end
+
+      # Adds a repo config.
+      #
+      # @param [String] name The semantic name of the repo.
+      # @return [void]
+      def add_repo(name)
+        repo_configs << Rosette::Core::RepoConfig.new(name, self).tap do |repo_config|
+          yield repo_config
+          repo_config.apply_integrations(repo_config)
+        end
+      end
+
+      # Retrieve a repo config by name.
+      #
+      # @param [String] name The semantic name of the repo to retrieve.
+      # @return [RepoConfig]
+      def get_repo(name)
+        repo_configs.find { |rc| rc.name == name }
+      end
+
+      # Set the datastore to use to store phrases and translations.
+      #
+      # @param [Const, String] datastore The datastore to use. When this
+      #   parameter is a string, +use_datastore+ will try to look up the
+      #   corresponding constant with a "DataStore" suffix. If it's a constant
+      #   instead, the constant is used without modifications.
+      # @param [Hash] options A hash of options passed to the datastore's
+      #   constructor.
+      # @return [void]
+      def use_datastore(datastore, options = {})
+        const = case datastore
+          when String
+            if const = find_datastore_const(datastore)
+              const
+            else
+              raise ArgumentError, "'#{datastore}' couldn't be found."
+            end
+          when Class
+            datastore
+          else
+            raise ArgumentError, "'#{datastore}' must be a String or Class."
+        end
+
+        @datastore = const.new(options)
+        nil
+      end
+
+      # Set the error reporter this config should use to report errors. The
+      # default error reporter is an instance of {PrintingErrorReporter}.
+      #
+      # @param [ErrorReporter] reporter The error reporter.
+      # @return [void]
+      def use_error_reporter(reporter)
+        @error_reporter = reporter
+      end
+
+      # Set the cache implementation. This must be one of the offerings in
+      # +ActiveSupport::Cache+:
+      # http://api.rubyonrails.org/classes/ActiveSupport/Cache.html
+      #
+      # @param [*] args The args to pass to ActiveSupport::Cache#lookup_store:
+      #   http://api.rubyonrails.org/classes/ActiveSupport/Cache.html#method-c-lookup_store
+      # @return [void]
+      def use_cache(*args)
+        @cache = ActiveSupport::Cache.lookup_store(args)
+      end
+
+      # Set the queue implementation. Queues must implement the
+      # [Rosette::Queuing::Queue] interface.
+      #
+      # @param [Const, String] queue The queue to use. When this parameter
+      #   is a string, +use_queue+ will try to look up the corresponding
+      #   constant with a "Queue" suffix. If it's a constant instead, the
+      #   constant is used without modifications.
+      # @param [Hash] options A hash of options passed to the queue's
+      #   constructor.
+      # @return [void]
+      def use_queue(queue)
+        const = case queue
+          when String
+            if const = find_queue_const(queue)
+              const
+            else
+              raise ArgumentError, "'#{queue}' couldn't be found."
+            end
+          when Class
+            queue
+          else
+            raise ArgumentError, "'#{queue}' must be a String or Class."
+        end
+
+        configurator = Rosette::Queuing::QueueConfigurator.new
+        yield configurator if block_given?
+        @queue = const.new(configurator)
+        nil
+      end
+
+      private
+
+      def find_datastore_const(name)
+        const_str = "#{Rosette::Core::StringUtils.camelize(name)}DataStore"
+
+        if Rosette::DataStores.const_defined?(const_str)
+          Rosette::DataStores.const_get(const_str)
+        end
+      end
+
+      def find_queue_const(name)
+        const_str = "#{Rosette::Core::StringUtils.camelize(name)}Queue"
+
+        if Rosette::Queuing.const_defined?(const_str)
+          Rosette::Queuing.const_get(const_str)::Queue
+        end
+      end
+    end
+
+  end
+end

data/lib/rosette/core/error_reporters/buffered_error_reporter.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Stores warnings errors in an internal buffer.
+    #
+    # @!attribute [r] errors
+    #   @return [Array<Exception>] the list of collected errors.
+    # @!attribute [r] warnings
+    #   @return [Array<Exception>] the list of collected warnings.
+    class BufferedErrorReporter < ErrorReporter
+      attr_reader :errors, :warnings
+
+      def initialize
+        reset
+      end
+
+      # Add an error object to the list of collected errors.
+      #
+      # @param [Exception] error The error object to add.
+      # @param [Hash] options A hash of options to record with the error.
+      # @return [void]
+      def report_error(error, options = {})
+        errors << { error: error, options: options }
+      end
+
+      # Add an error object to the list of collected warnings.
+      #
+      # @param [Exception] error The error object to add.
+      # @param [Hash] options A hash of options to record with the error.
+      # @return [void]
+      def report_warning(error, options = {})
+        warnings << { error: error, options: options }
+      end
+
+      # Clears all errors and warnings
+      #
+      # @return [void]
+      def reset
+        @errors = []
+        @warnings = []
+      end
+
+      # Returns true if one or more errors has been added, false otherwise.
+      #
+      # @return [Boolean] Whether or not one or more errors have been added.
+      def errors_found?
+        errors.size > 0
+      end
+
+      # Returns true if one or more warnings has been added, false otherwise.
+      #
+      # @return [Boolean] Whether or not one or more errors have been added.
+      def warnings_found?
+        warnings.size > 0
+      end
+
+      # Iterates over and yields each error. If no block is given, returns
+      # an +Enumerator+.
+      #
+      # @yield [error, options] each consecutive error and options hash.
+      # @yieldparam warning [Exception] the error
+      # @yieldparam options [Hash] the hash of options associated with +error+
+      # @return [nil, Enumerator] +nil+ if no block is given, an +Enumerator+
+      #   otherwise.
+      def each_error(&block)
+        if block_given?
+          errors.each do |error_hash|
+            yield error_hash[:error], error_hash[:options]
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      # Iterates over and yields each warning. If no block is given, returns
+      # an +Enumerator+.
+      #
+      # @yield [warning, options] each consecutive warning and options hash.
+      # @yieldparam warning [Exception] the warning
+      # @yieldparam options [Hash] the hash of options associated with +warning+
+      # @return [nil, Enumerator] +nil+ if no block is given, an +Enumerator+
+      def each_warning(&block)
+        if block_given?
+          warnings.each do |warning_hash|
+            yield warning_hash[:error], warning_hash[:options]
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+    end
+
+  end
+end

data/lib/rosette/core/error_reporters/error_reporter.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Error reporter interface.
+    class ErrorReporter
+      # Report an error.
+      #
+      # @raise [NotImplementedError]
+      def report_error(error, options = {})
+        raise NotImplementedError, 'Please use a derived class.'
+      end
+
+      # Report a warning.
+      #
+      # @raise [NotImplementedError]
+      def report_warning(error, options = {})
+        raise NotImplementedError, 'Please use a derived class.'
+      end
+
+      # Catch errors raised by the block and report them.
+      def with_error_reporting
+        yield
+      rescue Exception => e
+        report_error(e)
+      end
+    end
+
+  end
+end

data/lib/rosette/core/error_reporters/nil_error_reporter.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # An error reporter that does nothing.
+    class NilErrorReporter < ErrorReporter
+      # Get a reference to the only instance of +NilErrorReporter+.
+      #
+      # @return [NilErrorReporter] the only instance of +NilErrorReporter+.
+      def self.instance
+        @instance ||= new
+      end
+
+      # Does nothing.
+      # @return [nil]
+      def report_error(error, options = {}); end
+
+      # Does nothing.
+      # @return [nil]
+      def report_warning(error, options = {}); end
+    end
+
+  end
+end

data/lib/rosette/core/error_reporters/printing_error_reporter.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Prints errors.
+    #
+    # @!attribute [r] stream
+    #   @return [#write] a stream-like object to print errors to.
+    # @!attribute [r] print_stack_trace
+    #   @return [Boolean] whether or not to print a stack trace along with
+    #     the error message.
+    class PrintingErrorReporter < ErrorReporter
+      attr_reader :stream, :print_stack_trace
+      alias :print_stack_trace? :print_stack_trace
+
+      # Creates a new error reporter.
+      #
+      # @param [#write] stream The stream-like object to print errors to.
+      # @param [Hash] options A hash of options. Can contain:
+      #   * +print_stack_trace+: A boolean value indicating whether or not
+      #     a stack trace should be printed alongside the error message.
+      def initialize(stream, options = {})
+        @stream = stream
+        @print_stack_trace = options.fetch(:print_stack_trace, false)
+      end
+
+      # Print an error.
+      #
+      # @param [Exception] error The error to print.
+      # @param [Hash] options A hash of associated options (will also be
+      #   printed)
+      # @return [void]
+      def report_error(error, options = {})
+        stream.write("#{error.message}\n")
+
+        if print_stack_trace?
+          Array(error.backtrace).each do |line|
+            stream.write("#{line}\n")
+          end
+
+          stream.write(options.inspect)
+        end
+      end
+
+      # Print a warning. Warnings are treated the same as errors.
+      #
+      # @param [Exception] error The error to print.
+      # @param [Hash] options A hash of associated options (will also be
+      #   printed)
+      # @return [void]
+      def report_warning(error, options = {})
+        report_error(error, options)
+      end
+    end
+
+  end
+end