rosette-core 1.0.1

data/lib/rosette/core/string_utils.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # General-purpose string manipulation utilities.
+    class StringUtils
+      class << self
+        # Converts a snake_cased string into a CamelCased one.
+        #
+        # @example
+        #   StringUtils.camelize('foo_bar')  # => "FooBar"
+        #
+        # @param [String] str The snake_cased string to convert.
+        # @return [String]
+        def camelize(str)
+          str.gsub(/(^\w|[-_]\w)/) { $1[-1].upcase }
+        end
+      end
+    end
+
+  end
+end

data/lib/rosette/core/translation_status.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # A utility class that encapsulates how translated a set of phrases is.
+    # The class knows how to report translation percentages, etc.
+    #
+    # @!attribute [r] phrase_count
+    #   @return [Fixnum] the total number of phrases.
+    # @!attribute [r] locale_counts
+    #   @return [Hash<Fixnum>] a hash of locale codes to counts. Each count
+    #     represents the number of completed translations for that locale.
+    class TranslationStatus
+      attr_reader :phrase_count, :locale_counts
+
+      # Creates a new instance.
+      #
+      # @param [Fixnum] phrase_count The total number of phrases.
+      # @return [TranslationStatus]
+      def initialize(phrase_count)
+        @phrase_count = phrase_count
+        @locale_counts = {}
+      end
+
+      # Adds a locale code and count pair. The count should be the total number
+      # of completed translations in the locale.
+      #
+      # @param [String] locale_code
+      # @param [Fixnum] count
+      # @return [void]
+      def add_locale_count(locale_code, count)
+        locale_counts[locale_code] = count
+      end
+
+      # Returns true if the given locale is fully translated (i.e. the number of
+      # translations is greater than or equal to the number of phrases).
+      #
+      # @param [String] locale_code
+      # @return [Boolean]
+      def fully_translated_in?(locale_code)
+        (locale_counts[locale_code] || -1) >= phrase_count
+      end
+
+      # Returns true if every locale is fully translated, false otherwise.
+      #
+      # @return [Boolean]
+      def fully_translated?
+        locale_counts.all? do |locale_code, _|
+          fully_translated_in?(locale_code)
+        end
+      end
+
+      # Retrieves the number of completed translations for the given locale.
+      # Use this method in combination with +add_locale_count+.
+      def locale_count(locale_code)
+        locale_counts[locale_code]
+      end
+
+      # Retrieves a list of all the added locales.
+      #
+      # @return [Array<String>]
+      def locales
+        locale_counts.keys
+      end
+
+      # Calculates a translated percentage for the given locale.
+      #
+      # @param [String] locale_code
+      # @param [Fixnum] precision The precision to use when rounding the
+      #   percentage.
+      # @return [Float] the translation percentage, rounded to +precision+
+      #   decimal places.
+      def percent_translated(locale_code, precision = 2)
+        pct = locale_counts[locale_code] / phrase_count.to_f
+        [1.0, pct.round(precision)].min
+      end
+    end
+
+  end
+end

data/lib/rosette/core/validators.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Contains validators for validating the parameters of Rosette's commands.
+    module Validators
+      autoload :Validator,           'rosette/core/validators/validator'
+      autoload :CommitValidator,     'rosette/core/validators/commit_validator'
+      autoload :CommitsValidator,     'rosette/core/validators/commits_validator'
+      autoload :RepoValidator,       'rosette/core/validators/repo_validator'
+      autoload :SerializerValidator, 'rosette/core/validators/serializer_validator'
+      autoload :LocaleValidator,     'rosette/core/validators/locale_validator'
+      autoload :EncodingValidator,   'rosette/core/validators/encoding_validator'
+    end
+
+  end
+end

data/lib/rosette/core/validators/commit_validator.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Validators
+
+      # Validates the existence of a commit.
+      #
+      # @example
+      #   v = CommitValidator.new
+      #   v.valid?('73cd130a42017d794ffa86ef0d255541d518a7b3', 'my_repo', config)
+      #   # => true
+      #
+      #   v.valid?('non-existent-ref', 'my_repo', config)
+      #   # => false
+      #
+      #   v.messages  # => ["Unable to find commit 'non-existent-ref'."]
+      class CommitValidator < Validator
+        # Returns true if the commit is valid, false otherwise. Also returns false if
+        # +repo_name+ isn't a valid repo configured in +configuration+.
+        #
+        # @param [String] commit_str The commit to validate.
+        # @param [String] repo_name The repo to look for +commit_str+ in.
+        # @param [Configurator] configuration The Rosette configuration to use.
+        # @return [Boolean]
+        def valid?(commit_str, repo_name, configuration)
+          if repo_config = configuration.get_repo(repo_name)
+            if commit_str
+              commit = repo_config.repo.get_rev_commit(commit_str)
+              validate_commit(commit)
+            else
+              messages << "Nil commit passed."
+              false
+            end
+          else
+            messages << "Unable to find repo #{repo_name}."
+            false
+          end
+        rescue Java::OrgEclipseJgitErrors::MissingObjectException, Java::JavaLang::IllegalArgumentException
+          messages << "Unable to find commit '#{commit_str}'."
+          false
+        end
+
+        private
+
+        def validate_commit(commit)
+          if options.fetch(:allow_merge_commit, true)
+            true
+          else
+            if commit.getParentCount > 1
+              messages << "Unable to validate #{commit.getId.name} because it's a merge commit."
+              false
+            else
+              true
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/validators/commits_validator.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Validators
+
+      # Validates the existence of an array of commits.
+      #
+      # @example
+      #   v = CommitsValidator.new
+      #   v.valid?(['73cd130a42017d794ffa86ef0d255541d518a7b3'], 'my_repo', config)
+      #   # => true
+      #
+      #   v.valid?(['non-existent-ref'], 'my_repo', config)
+      #   # => false
+      #
+      #   v.messages  # => ["Unable to find commit 'non-existent-ref'."]
+      class CommitsValidator < CommitValidator
+        def valid?(commit_strs, repo_name, configuration)
+          if commit_strs
+            commit_strs.all? do |commit_str|
+              super(commit_str, repo_name, configuration)
+            end
+          else
+            false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/validators/encoding_validator.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Validators
+
+      # Validates an encoding.
+      #
+      # @example
+      #   v = EncodingValidator.new
+      #   v.valid?(Encoding::UTF_8, nil, nil) # => true
+      #   v.valid?('foo', nil, nil)  # => false
+      #   v.messages  # => ["Encoding 'foo' was not recognized."]
+      class EncodingValidator < Validator
+        # Returns true if the encoding is valid, false otherwise.
+        #
+        # @param [String, Encoding] encoding The encoding to validate.
+        # @param [String] repo_name (not used)
+        # @param [Configurator] configuration (not used)
+        # @return [Boolean]
+        def valid?(encoding, repo_name, configuration)
+          Encoding.find(encoding)
+          true
+        rescue ArgumentError
+          messages << "Encoding '#{encoding}' was not recognized."
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/validators/locale_validator.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Validators
+
+      # Validates a locale by making sure the given repo has been configured
+      # to support it.
+      #
+      # @example
+      #   v = LocaleValidator.new
+      #   v.valid?('ko-KR', 'my_repo', config)   # => true
+      #   v.valid?('foo-BAR', 'my_repo', config) # => false
+      #   v.messages  # => ["Repo 'my_repo' doesn't support the 'foo-BAR' locale"]
+      class LocaleValidator < Validator
+        # Returns true if the locale is valid, false otherwise.
+        #
+        # @param [String] locale_code The locale to validate.
+        # @param [String] repo_name The repo to use. This method checks the
+        #   entry in +configuration+ for +repo_name+ to see if it supports
+        #   +locale_code+.
+        # @param [Configurator] configuration The Rosette configuration to use.
+        # @return [Boolean]
+        def valid?(locale_code, repo_name, configuration)
+          repo = configuration.get_repo(repo_name)
+          if locale_code && repo.get_locale(locale_code)
+            true
+          else
+            messages << "Repo '#{repo_name}' doesn't support the '#{locale_code}' locale"
+            false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/validators/repo_validator.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Validators
+
+      # Validates a repo by making sure it has been configured.
+      #
+      # @example
+      #   v = RepoValidator.new
+      #   v.valid?('my_repo', nil, config)   # => true
+      #   v.valid?('bad_repo', nil, config)  # => false
+      #   v.messages  # => ["Unable to find repo 'bad_repo'."]
+      class RepoValidator < Validator
+        # Returns true if the repo is valid, false otherwise
+        #
+        # @param [String] repo_name The repo to validate.
+        # @param [String] _ (not used)
+        # @param [Configurator] configuration The Rosette configuration to use.
+        # @return [Boolean]
+        def valid?(repo_name, _, configuration)
+          if !configuration.get_repo(repo_name)
+            messages << "Unable to find repo '#{repo_name}'."
+            false
+          else
+            true
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/validators/serializer_validator.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Validators
+
+      # Validates a serializer by making sure the given repo has been configured
+      # to support it.
+      #
+      # @example
+      #   v = SerializerValidator.new
+      #   v.valid?('yaml/rails', 'my_repo', config)  # => true
+      #   v.valid?('yaml/blarg', 'my_repo', config)  # => false
+      #   v.messages  # => ["Unable to find serializer 'yaml/blarg'."]
+      class SerializerValidator < Validator
+        # Returns true if the serializer is valid, false otherwise.
+        #
+        # @param [String] serializer_id The serializer to validate.
+        # @param [String] repo_name The repo to use. This method checks the
+        #   entry in +configuration+ for +repo_name+ to see if it supports
+        #   +serializer_id+.
+        # @param [Configurator] configuration The Rosette configuration to use.
+        # @return [Boolean]
+        def valid?(serializer_id, repo_name, configuration)
+          repo = configuration.get_repo(repo_name)
+          if repo.get_serializer_config(serializer_id)
+            true
+          else
+            messages << "Unable to find serializer '#{serializer_id}'."
+            false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/validators/validator.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Validators
+
+      # Base class for validators.
+      #
+      # @!attribute [r] options
+      #   @return [Hash] a hash of options.
+      class Validator
+        attr_reader :options
+
+        # Creates a new validator.
+        #
+        # @param [Hash] options A hash of options.
+        def initialize(options = {})
+          @options = options
+        end
+
+        # An array of error messages. Populated when +#valid?+ is called.
+        #
+        # @return [Array<String>] The list of error messages.
+        def messages
+          @messages ||= []
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/version.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    # +rosette-core+'s current version.
+    VERSION = "1.0.1"
+  end
+end

data/lib/rosette/data_stores.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module Rosette
+
+  # Namespace for Rosette's data stores.
+  module DataStores
+    autoload :Errors,       'rosette/data_stores/errors'
+    autoload :PhraseStatus, 'rosette/data_stores/phrase_status'
+  end
+
+end

data/lib/rosette/data_stores/errors.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+module Rosette
+  module DataStores
+
+    # Errors that can be raised during data store operations.
+    module Errors
+      # Raised when an error occurs when adding a new translation.
+      class AddTranslationError < StandardError; end
+
+      # Raised when a phrase with the given attributes cannot be found.
+      class PhraseNotFoundError < StandardError; end
+
+      # Raised when the appropriate translation parameters aren't provided.
+      class MissingParamError < StandardError; end
+
+      # Raised when a commit log entry can't be updated.
+      class CommitLogUpdateError < StandardError; end
+
+      # Raised when one of the locale entries for a commit log can't be
+      # updated.
+      class CommitLogLocaleUpdateError < StandardError; end
+    end
+
+  end
+end