rosette-core 1.0.1

data/lib/rosette/core/commands/git/diff_entry.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Represents an added, removed, or changed phrase.
+      #
+      # @!attribute [r] phrase
+      #   @return [Rosette::Core::Phrase] the added/removed/modified phrase.
+      # @!attribute [r] state
+      #   @return [Symbol] one of +:added+, +:removed+, or +:modified+.
+      # @!attribute [r] old_phrase
+      #   @return [Rosette::Core::Phrase] +phrase+ before it was modified.
+      #     This value is generally only set if +state+ is set to +:modified+.
+      class DiffEntry
+        attr_reader :phrase, :state, :old_phrase
+
+        # Creates a new {DiffEntry}.
+        #
+        # @param [Rosette::Core::Phrase] phrase The added/removed/modified phrase.
+        # @param [Symbol] state One of +:added+, +:removed+, or +:modified+.
+        # @param [Rosette::Core::Phrase] old_phrase +phrase+ before it was modified.
+        #   This argument is usually only included if +state+ is +:modified+.
+        def initialize(phrase, state, old_phrase = nil)
+          @phrase = phrase
+          @state = state
+          @old_phrase = old_phrase
+        end
+
+        # Serializes the attributes of this entry into a hash.
+        #
+        # @return [Hash] the attributes of the phrase. If +state+ is set to +:modified+,
+        #   the key of the old phrase is included as +:old_key+.
+        def to_h
+          phrase.to_h.tap do |hash|
+            hash[:old_key] = old_phrase.key if old_phrase
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/git/fetch_command.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Performs a git fetch on a repository. New branches and commits will
+      # be downloaded from the remote server (often called "origin") and
+      # become part of the local copy.
+      #
+      # @example
+      #   FetchCommand.new(configuration)
+      #     .set_repo_name('my_repo')
+      #     .execute
+      class FetchCommand < GitCommand
+        include WithRepoName
+
+        # Perform the fetch operation.
+        # @return [Java::OrgEclipseJgitTransport::FetchResult]
+        def execute
+          get_repo(repo_name).repo.fetch
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/git/repo_snapshot_command.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Takes a snapshot of a repository and returns the snapshot hash. Snapshots
+      # are simple hashes that map file paths to git commit ids. The commit ids
+      # indicate in which commit the corresponding file last changed.
+      #
+      # @!attribute [Array] paths
+      #   @return [Array] the paths to consider when taking the snapshot. Any paths
+      #     that do not exist in this array will not appear in the snapshot.
+      class RepoSnapshotCommand < GitCommand
+        attr_reader :paths
+
+        include WithSnapshots
+        include WithRepoName
+        include WithRef
+
+        # Set the paths that will be included in the snapshot.
+        #
+        # @param [Array] paths The paths to include in the snapshot.
+        # @return [self]
+        def set_paths(paths)
+          @paths = paths
+          self
+        end
+
+        # Take the snapshot.
+        #
+        # @return [Hash] the snapshot hash (file path to commit id pairs).
+        def execute
+          take_snapshot(get_repo(repo_name), commit_id, paths)
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/git/show_command.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+
+java_import 'org.eclipse.jgit.revwalk.RevWalk'
+
+module Rosette
+  module Core
+    module Commands
+
+      # Show the phrases that were added, removed, or modified directly by
+      # the given commit. Essentially this means a diff against the parent.
+      #
+      # @example
+      #   cmd = ShowCommand.new(configuration)
+      #     .set_repo_name('my_repo')
+      #     .set_ref('my_branch')
+      #
+      #   cmd.execute
+      #   # {
+      #   #   added: [
+      #   #     { key: 'Foo', ... },
+      #   #   ],
+      #   #   removed: [
+      #   #     { key: 'I got deleted', ... }
+      #   #   ],
+      #   #   modified: [
+      #   #     { key: 'New value', old_key: 'Old value', ... }
+      #   #   ]
+      #   # }
+      class ShowCommand < DiffBaseCommand
+        include WithRepoName
+        include WithRef
+
+        # Computes the show (i.e. parent diff).
+        # @return [Hash] a hash of differences, grouped by added/removed/modified keys. Each
+        #   value is an array of phrases. For added and removed phrases, the phrase hashes
+        #   will contain normal phrase attributes. For changed phrases, the phrase hashes
+        #   will contain normal phrase attributes plus a special +old_key+ attribute that
+        #   contains the previous key of the phrase. See the example above for a visual
+        #   representation of the diff hash.
+        def execute
+          parent_commit_ids = build_parent_commit_list
+          phrase_diff = diff_between(commit_id, parent_commit_ids)
+          filter_phrase_diff(commit_id, parent_commit_ids, phrase_diff)
+        end
+
+        protected
+
+        def filter_phrase_diff(commit_id, parent_commit_ids, phrase_diff)
+          phrase_diff.each_with_object({}) do |(state, diff_entries), ret|
+            ret[state] = diff_entries.select do |diff_entry|
+              diff_entry.phrase.commit_id == commit_id ||
+                diff_entry.state == :removed
+            end
+          end
+        end
+
+        def build_parent_commit_list
+          repo.parents_of(repo.get_rev_commit(commit_id)).map do |parent|
+            if strict?
+              parent.getId.name
+            else
+              get_closest_processed_parent(parent.getId.name)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/git/snapshot_command.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Takes a snapshot and returns a list of phrases. This is different from
+      # {RepoSnapshotCommand} in that it doesn't return the snapshot hash itself,
+      # but instead the phrases contained in the snapshot's commits.
+      #
+      # @example
+      #   cmd = SnapshotCommand.new(configuration)
+      #     .set_repo_name('my_repo')
+      #     .set_ref('master')
+      #
+      #   cmd.execute
+      #   # => [<Phrase #ba012cd key: 'foobar'>, ...]
+      #
+      # @!attribute [Array] paths
+      #   @return [Array] the paths to consider when taking the snapshot. Any paths
+      #     that do not exist in this array will not appear in the snapshot.
+      class SnapshotCommand < GitCommand
+        attr_reader :paths
+
+        include WithSnapshots
+        include WithRepoName
+        include WithRef
+
+        # Set the paths that will be included in the snapshot.
+        #
+        # @param [Array] paths The paths to include in the snapshot.
+        # @return [self]
+        def set_paths(paths)
+          @paths = paths
+          self
+        end
+
+        # Take the snapshot.
+        #
+        # @return [Array<Rosette::Core::Phrase>] the list of phrases from the
+        #   snapshot.
+        def execute
+          snapshot = take_snapshot(get_repo(repo_name), commit_id, paths)
+          datastore.phrases_by_commits(repo_name, snapshot).to_a
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/git/status_command.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Computes the status of a git ref. Statuses contain the number of
+      # translations per locale as well as the state of the commit (pending,
+      # untranslated, or translated).
+      #
+      # @see Rosette::DataStores::PhraseStatus
+      #
+      # @example
+      #   cmd = StatusCommand.new(configuration)
+      #     .set_repo_name('my_repo')
+      #     .set_ref('master')
+      #
+      #   cmd.execute
+      #   # =>
+      #   # {
+      #   #   commit_id: "5756196042a3a307b43fd1a7092ecc6710eec42a",
+      #   #   status: "PENDING",
+      #   #   phrase_count: 100,
+      #   #   locales: [{
+      #   #     locale: 'fr-FR',
+      #   #     percent_translated: 0.5,
+      #   #     translated_count: 50
+      #   #   }, ... ]
+      #   # }
+      class StatusCommand < GitCommand
+        include WithRepoName
+        include WithRef
+
+        # Computes the status for the configured repository and git ref. The
+        # status is computed by identifying the branch the ref belongs to, then
+        # examining and merging the statuses of all commits that belong to
+        # that branch.
+        #
+        # @see Rosette::DataStores::PhraseStatus
+        #
+        # @return [Hash] a hash of status information for the ref:
+        #   * +commit_id+: the commit id of the ref the status came from.
+        #   * +status+: One of +"FETCHED"+, +"EXTRACTED"+, +"PUSHED"+,
+        #     +"FINALIZED"+, or +"NOT_FOUND"+.
+        #   * +phrase_count+: The number of phrases found in the commit.
+        #   * +locales+: A hash of locale codes to locale statuses having these
+        #     entries:
+        #     * +percent_translated+: The percentage of +phrase_count+ phrases
+        #       that are currently translated in +locale+ for this commit.
+        #       In other words, +translated_count+ +/+ +phrase_count+.
+        #     * +translated_count+: The number of translated phrases in +locale+
+        #       for this commit.
+        def execute
+          repo_config = get_repo(repo_name)
+          rev_walk = RevWalk.new(repo_config.repo.jgit_repo)
+          all_refs = repo_config.repo.all_refs.values
+          refs = repo_config.repo.refs_containing(
+            commit_id, rev_walk, all_refs
+          )
+
+          commit_logs = commit_logs_for(
+            refs.map(&:getName), repo_config, rev_walk, all_refs
+          )
+
+          status, phrase_count, locale_statuses = derive(
+            refs, commit_logs, repo_config
+          )
+
+          rev_walk.dispose
+
+          {
+            status: status,
+            commit_id: commit_id,
+            phrase_count: phrase_count,
+            locales: locale_statuses
+          }
+        end
+
+        protected
+
+        def derive(refs, commit_logs, repo_config)
+          status = derive_status(refs, commit_logs)
+          phrase_count = BranchUtils.derive_phrase_count_from(commit_logs)
+          locale_statuses = BranchUtils.derive_locale_statuses_from(
+            commit_logs, repo_name, datastore, phrase_count
+          )
+
+          [
+            status, phrase_count,
+            BranchUtils.fill_in_missing_locales(
+              repo_config.locales, locale_statuses
+            )
+          ]
+        end
+
+        def derive_status(refs, commit_logs)
+          if all_refs_exist?(refs)
+            BranchUtils.derive_status_from(commit_logs)
+          else
+            Rosette::DataStores::PhraseStatus::NOT_FOUND
+          end
+        end
+
+        def all_refs_exist?(refs)
+          refs.all? do |ref|
+            datastore.commit_log_exists?(repo_name, ref.getObjectId.name)
+          end
+        end
+
+        def commit_logs_for(branch_names, repo_config, rev_walk, all_refs)
+          statuses = Rosette::DataStores::PhraseStatus.incomplete
+          commit_logs = datastore.each_commit_log_with_status(repo_name, statuses)
+
+          commit_logs.each_with_object([]) do |commit_log, ret|
+            refs = repo_config.repo.refs_containing(
+              commit_log.commit_id, rev_walk, all_refs
+            )
+
+            if refs.any? { |ref| branch_names.include?(ref.getName) }
+              ret << commit_log
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/git/with_non_merge_ref.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    module Commands
+
+      # Mixin that handles configuration and validation of a git ref or commit id.
+      # This module is similar to {Rosette::Core::Commands::WithRef} except that
+      # it will fail to validate merge refs. It is meant to be mixed into the classes
+      # in {Rosette::Core::Commands}. Required to be used in combination with
+      # {Rosette::Core::Commands::WithRepoName}.
+      #
+      # @see Rosette::Core::Commands::WithRef
+      # @see Rosette::Core::Commands::WithRepoName
+      #
+      # @example
+      #   class MyCommand
+      #     include WithRepoName
+      #     include WithNonMergeRef
+      #   end
+      #
+      #   cmd = MyCommand.new
+      #     .set_repo_name('my_repo')
+      #     .set_ref('master')
+      #
+      #   cmd.commit_str  # => "master"
+      #   cmd.commit_id   # => "67f0e9a60dfe39430b346086f965e6c94a8ddd24"
+      #
+      #   cmd.set_ref('non_existant_ref')
+      #   cmd.valid?    # => false
+      #   cmd.messages  # => { commit_str: ["Unable to find commit 'non_existent_ref'"] }
+      module WithNonMergeRef
+        include WithRef
+
+        protected
+
+        def self.included(base)
+          if base.respond_to?(:validate)
+            base.validate :commit_str, {
+              type: :commit, allow_merge_commit: false
+            }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rosette/core/commands/git/with_ref.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+
+require 'thread'
+
+module Rosette
+  module Core
+    module Commands
+
+      # Mixin that handles configuration and validation of a git ref or commit id.
+      # Meant to be mixed into the classes in {Rosette::Core::Commands}. Required
+      # to be used in combination with {Rosette::Core::Commands::WithRepoName}.
+      #
+      # @see Rosette::Core::Commands::WithNonMergeRef
+      # @see Rosette::Core::Commands::WithRepoName
+      #
+      # @example
+      #   class MyCommand < Rosette::Core::Commands::Command
+      #     include WithRepoName
+      #     include WithRef
+      #   end
+      #
+      #   cmd = MyCommand.new
+      #     .set_repo_name('my_repo')
+      #     .set_ref('master')
+      #
+      #   cmd.commit_str  # => "master"
+      #   cmd.commit_id   # => "67f0e9a60dfe39430b346086f965e6c94a8ddd24"
+      #   cmd.valid?      # => true
+      #
+      #   cmd.set_ref('non_existant_ref')
+      #   cmd.valid?    # => false
+      #   cmd.messages  # => { commit_str: ["Unable to find commit 'non_existent_ref'"] }
+      #
+      # @!attribute [r] commit_str
+      #   @return [String] the raw value as set by either {#set_ref} or {#set_commit_id}.
+      module WithRef
+        attr_reader :commit_str
+
+        # Set the git ref (i.e. a branch name). Calling this method after {#set_commit_id}
+        # will overwrite the commit id value. In other words, it's generally a good idea to
+        # only call one of {#set_commit_id} or {#set_ref} but not both.
+        #
+        # @param [String] ref_str The git ref.
+        # @return [self]
+        def set_ref(ref_str)
+          @commit_str = ref_str
+          self
+        end
+
+        # Set the git commit id. Calling this method after {#set_ref} will overwrite the ref value.
+        # In other words, it's generally a good idea to only call one of {#set_commit_id} or {#set_ref}
+        # but not both.
+        #
+        # @param [String] commit_id The commit id.
+        # @return [self]
+        def set_commit_id(commit_id)
+          @commit_str = commit_id
+          self
+        end
+
+        # Resolves the given git ref or commit id and returns the corresponding commit id.
+        # If {#set_ref} was used to set a git ref (i.e. branch name), this method looks up
+        # and returns the corresponding commit id. If {#set_commit_id} was used to set a
+        # commit id, then that commit id is validated and returned.
+        #
+        # @return [String] The commit id set via either {#set_ref} or {#set_commit_id}.
+        # @raise [Java::OrgEclipseJgitErrors::MissingObjectException, Java::JavaLang::IllegalArgumentException]
+        #   If either the commit id doesn't exist or the ref can't be found.
+        def commit_id
+          @commit_id ||= begin
+            REV_COMMIT_MUTEX.synchronize do
+              get_repo(repo_name)
+                .repo.get_rev_commit(@commit_str)
+                .getId.name
+            end
+          end
+        end
+
+        private
+
+        REV_COMMIT_MUTEX = Mutex.new
+
+        def self.included(base)
+          if base.respond_to?(:validate)
+            base.validate :commit_str, type: :commit
+          end
+        end
+      end
+
+    end
+  end
+end