rosette-core 1.0.1

data/lib/rosette/core/resolvers/serializer_id.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Logic for handling serializer ids. Serializer ids are strings that refer to
+    # a particular serializer class. For example, the id 'yaml/rails' refers to
+    # +Rosette::Serializers::YamlSerializer::RailsSerializer+.
+    #
+    # @example
+    #   SerializerId.resolve('yaml/rails')
+    #   # => Rosette::Serializers::YamlSerializer::RailsSerializer
+    class SerializerId < Resolver
+      class << self
+
+        # Parses and identifies the class constant for the given serializer id.
+        #
+        # @param [Class, String] serializer_id When given a class, returns the
+        #   class. When given a string, parses and identifies the corresponding
+        #   class constant in +namespace+.
+        # @param [Class] namespace The namespace to look in.
+        # @return [Class] The identified class constant.
+        def resolve(serializer_id, namespace = Rosette::Serializers)
+          super
+        end
+
+        private
+
+        def suffix
+          'Serializer'
+        end
+
+      end
+    end
+
+  end
+end

data/lib/rosette/core/snapshots/cached_head_snapshot_factory.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+require 'digest/sha1'
+
+module Rosette
+  module Core
+
+    # Takes head snapshots and caches the results. Take a look at
+    # +ActiveSupport::Cache+ for a good set of cache stores that conform to the
+    # right interface.
+    #
+    # @see http://api.rubyonrails.org/classes/ActiveSupport/Cache.html
+    #
+    # @!attribute [r] cache
+    #   @return [#fetch] the cache store. This can be any object that responds
+    #     to +#fetch+ (and passes a block).
+    class CachedHeadSnapshotFactory < HeadSnapshotFactory
+      attr_reader :cache
+
+      # Creates a new cached head snapshot factory that uses the given cache.
+      #
+      # @param [#fetch] cache The cache to use.
+      def initialize(cache)
+        @cache = cache
+      end
+
+      protected
+
+      def process_ref(rev_walk, ref)
+        cache_key = head_snapshot_cache_key(
+          repo_config.name,
+          repo_config.repo.get_rev_commit(ref, rev_walk).getId.name
+        )
+
+        cache.fetch(cache_key) do
+          super
+        end
+      end
+
+      def head_snapshot_cache_key(repo_name, commit_id)
+        ['head_snapshots', repo_config.name, commit_id].join('/')
+      end
+
+      def head_snapshot_factory
+        Rosette::Core::HeadSnapshotFactory
+      end
+
+    end
+
+  end
+end

data/lib/rosette/core/snapshots/cached_snapshot_factory.rb

@@ -0,0 +1,67 @@
+# encoding: UTF-8
+
+require 'digest/sha1'
+
+module Rosette
+  module Core
+
+    # Takes snapshots and caches the results. Take a look at
+    # +ActiveSupport::Cache+ for a good set of cache stores that conform to the
+    # right interface.
+    #
+    # @see http://api.rubyonrails.org/classes/ActiveSupport/Cache.html
+    #
+    # @!attribute [r] cache
+    #   @return [#fetch] the cache store. This can be any object that responds
+    #     to +#fetch+ (and passes a block).
+    class CachedSnapshotFactory
+      attr_reader :cache
+
+      # Creates a new cached snapshot factory that uses the given cache.
+      #
+      # @param [#fetch] cache The cache to use.
+      def initialize(cache)
+        @cache = cache
+      end
+
+      # Takes the snapshot.
+      #
+      # @param [RepoConfig] repo_config The repo config for the repo to take
+      #   the snapshot for.
+      # @param [String] commit_id The commit id to take the snapshot of.
+      # @param [Array<String>] paths The list of paths to include in the
+      #   snapshot. If +paths+ is empty, this method will return a snapshot
+      #   that contains all paths.
+      # @return [Hash<String, String>] The snapshot hash (path to commit id
+      #   pairs).
+      def take_snapshot(repo_config, commit_id, paths = [])
+        paths = Array(paths)
+        cache_key = snapshot_cache_key(repo_config.name, commit_id, paths)
+
+        cache.fetch(cache_key) do
+          factory = snapshot_factory.new
+            .set_repo_config(repo_config)
+            .set_start_commit_id(commit_id)
+
+          factory.set_paths(paths) if paths.size > 0
+          factory.take_snapshot
+        end
+      end
+
+      private
+
+      def snapshot_cache_key(repo_name, commit_id, paths)
+        ['snapshots', repo_name, commit_id, path_digest(paths)].join('/')
+      end
+
+      def path_digest(paths)
+        Digest::MD5.hexdigest(paths.join)
+      end
+
+      def snapshot_factory
+        Rosette::Core::SnapshotFactory
+      end
+    end
+
+  end
+end

data/lib/rosette/core/snapshots/head_snapshot_factory.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+java_import 'org.eclipse.jgit.revwalk.RevWalk'
+java_import 'org.eclipse.jgit.revwalk.filter.RevFilter'
+
+module Rosette
+  module Core
+
+    # Takes a snapshot of all the repository's heads. A "head" snapshot is a
+    # key/value map (hash) of git refs (i.e. branch names) to commit ids,
+    # where the commit ids are the first non-merge commits for each branch.
+    #
+    # @example
+    #   snapshot = HeadSnapshotFactory.new
+    #     .set_repo_config(config)
+    #     .take_snapshot
+    #
+    # @!attribute [r] repo_config
+    #   @return [RepoConfig] the repo config that contains the repo to take
+    #     the snapshot for.
+    class HeadSnapshotFactory
+      attr_reader :repo_config
+
+      # Sets the repo config that contains the repo to take the snapshot for.
+      #
+      # @param [RepoConfig] repo_config
+      # @return [self]
+      def set_repo_config(repo_config)
+        @repo_config = repo_config
+        self
+      end
+
+      # Takes the snapshot.
+      #
+      # @return [Hash<String, String>] The head snapshot hash of refs to
+      #   commit ids.
+      def take_snapshot
+        rev_walk = RevWalk.new(repo_config.repo.jgit_repo)
+        repo_config.repo.all_head_refs.each_with_object({}) do |ref, snapshot|
+          snapshot[ref] = process_ref(rev_walk, ref)
+        end
+      end
+
+      protected
+
+      def process_ref(rev_walk, ref)
+        rev_walk.reset
+        rev_walk.markStart(repo_config.repo.get_rev_commit(ref, rev_walk))
+        rev_walk.setRevFilter(RevFilter::NO_MERGES)
+
+        if rev_commit = rev_walk.next
+          rev_commit.getId.name
+        end
+      end
+    end
+
+  end
+end

data/lib/rosette/core/snapshots/repo_config_path_filter.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+java_import 'org.eclipse.jgit.treewalk.filter.TreeFilter'
+
+module Rosette
+  module Core
+
+    # A jgit tree filter that filters by the path rules specified in the given
+    # {RepoConfig}.
+    #
+    # @example
+    #   filter = RepoConfigPathFilter.create(repo_config)
+    #   factory = Rosette::Core::SnapshotFactory.new
+    #     .set_repo('my_repo')
+    #
+    #   factory.add_filter(filter)
+    #   factory.take_snapshot(...)
+    #
+    # @!attribute [rw] repo_config
+    #   @return [Array<String>] the configuration to use when filtering paths
+    class RepoConfigPathFilter < TreeFilter
+      # Creates a new filter with the given repo config.
+      #
+      # @param [RepoConfig] repo_config The configuration to use when
+      #   filtering paths
+      # @return [FileTypeFilter]
+      def self.create(repo_config)
+        # Do this because jruby is dumb (i.e. doesn't let you override java
+        # constructors)
+        new.tap do |obj|
+          obj.repo_config = repo_config
+        end
+      end
+
+      attr_accessor :repo_config
+
+      # Overridden. Returns true if the current file matches false otherwise.
+      # Generally this method is only called by Jgit internals.
+      #
+      # @param [Java::OrgEclipseJgitTreewalk::TreeWalk] walker The walker with
+      #   the current file.
+      # @return [Boolean]
+      def include(walker)
+        if walker.isSubtree
+          true
+        else
+          path = walker.getPathString
+
+          if repo_config.extractor_configs.size > 0
+            repo_config.extractor_configs.any? do |extractor_config|
+              extractor_config.matches?(path)
+            end
+          else
+            true
+          end
+        end
+      end
+
+      # Returns true if this filter should be applied recursively, false otherwise.
+      # For this particular filter, always returns true.
+      #
+      # @return [Boolean]
+      def shouldBeRecursive
+        true
+      end
+
+      # Clones this filter. For this particular filter, always returns self.
+      #
+      # @return [self]
+      def clone
+        self
+      end
+
+      # Returns a string representation of this filter.
+      #
+      # @return [String]
+      def to_s
+        "REPO_CONFIG_FILTER"
+      end
+    end
+
+  end
+end

data/lib/rosette/core/snapshots/snapshot_factory.rb

@@ -0,0 +1,184 @@
+# encoding: UTF-8
+
+java_import 'org.eclipse.jgit.revwalk.RevWalk'
+java_import 'org.eclipse.jgit.revwalk.filter.RevFilter'
+java_import 'org.eclipse.jgit.treewalk.EmptyTreeIterator'
+java_import 'org.eclipse.jgit.treewalk.TreeWalk'
+java_import 'org.eclipse.jgit.treewalk.filter.AndTreeFilter'
+java_import 'org.eclipse.jgit.treewalk.filter.PathFilter'
+java_import 'org.eclipse.jgit.treewalk.filter.PathFilterGroup'
+java_import 'org.eclipse.jgit.treewalk.filter.TreeFilter'
+
+require 'set'
+
+module Rosette
+  module Core
+
+    # Takes snapshots of git repos. A snapshot is a simple key/value map (hash)
+    # of paths to commit ids. The commit id is the last time the file changed.
+    #
+    # @example
+    #   snapshot = SnapshotFactory.new
+    #     .set_repo_config(repo_config)
+    #     .set_start_commit_id('73cd130a42017d794ffa86ef0d255541d518a7b3')
+    #     .take_snapshot
+    #
+    # @!attribute [r] repo_config
+    #   @return [Repo] the +RepoConfig+ object to use when filtering paths, etc.
+    # @!attribute [r] start_commit_id
+    #   @return [String] the git commit id to start at. File changes that
+    #     occurred more recently than this commit will not be reflected in
+    #     the snapshot.
+    class SnapshotFactory
+      attr_reader :repo_config, :start_commit_id, :paths
+
+      # Creates a new factory.
+      def initialize
+        reset
+      end
+
+      # Sets the Rosette repo object to use.
+      #
+      # @param [Repo] repo The Rosette repo object to use.
+      # @return [self]
+      def set_repo_config(repo_config)
+        @repo_config = repo_config
+        self
+      end
+
+      # Sets the starting commit id. File changes that occurred more recently
+      # than this commit will not be reflected in the snapshot. In other words,
+      # this is the commit id to take the snapshot of.
+      #
+      # @param [String] commit_id The starting commit id.
+      # @return [self]
+      def set_start_commit_id(commit_id)
+        @start_commit_id = commit_id
+        self
+      end
+
+      # 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
+
+      # Takes the snapshot.
+      #
+      # @return [Hash<String, String>] The snapshot hash (path to commit id
+      #   pairs).
+      def take_snapshot
+        build_hash.tap do
+          reset
+        end
+      end
+
+      private
+
+      def build_hash
+        repo = repo_config.repo
+        rev_walk = RevWalk.new(repo.jgit_repo)
+        rev_commit = repo.get_rev_commit(start_commit_id, rev_walk)
+        path_set = (make_path_set(rev_commit) + paths).to_a
+        num_replacements = 0
+
+        tree_filter = if path_set.size > 0
+          path_filter = if repo_config && path_set.empty?
+            RepoConfigPathFilter.create(repo_config)
+          else
+            PathFilterGroup.createFromStrings(path_set)
+          end
+
+          AndTreeFilter.create(path_filter, TreeFilter::ANY_DIFF)
+        end
+
+        {}.tap do |path_hash|
+          tree_walk = TreeWalk.new(repo.jgit_repo)
+          rev_walk.markStart(rev_commit)
+
+          while cur_commit = rev_walk.next
+            cur_commit_id = cur_commit.getId.name
+
+            tree_walk.reset
+            parent_count = cur_commit.getParentCount
+
+            if parent_count == 0
+              tree_walk.addTree(EmptyTreeIterator.new)
+            else
+              parent_count.times do |i|
+                tree_walk.addTree(cur_commit.getParent(i).getTree)
+              end
+            end
+
+            tree_walk.addTree(cur_commit.getTree)
+            tree_walk.setFilter(tree_filter)
+            tree_walk.setRecursive(true)
+
+            each_file_in(tree_walk) do |walker|
+              path = walker.getPathString
+
+              unless path_hash[path]
+                path_hash[path] = cur_commit_id
+                num_replacements += 1
+              end
+            end
+
+            if num_replacements > path_hash.size
+              break
+            end
+          end
+
+          rev_walk.dispose
+          tree_walk.release
+        end
+      end
+
+      def make_path_set(rev_commit)
+        path_gatherer = make_path_gatherer(rev_commit)
+
+        files = each_file_in(path_gatherer).each_with_object(Set.new) do |walker, ret|
+          ret << walker.getPathString
+        end
+
+        path_gatherer.release
+        files
+      end
+
+      def make_path_gatherer(rev_commit)
+        TreeWalk.new(repo_config.repo.jgit_repo).tap do |walker|
+          walker.addTree(rev_commit.getTree)
+          walker.setRecursive(true)
+
+          # explicit paths take precedence over repo config ones
+          filter = if paths.size > 0
+            PathFilterGroup.createFromStrings(paths)
+          elsif repo_config
+            RepoConfigPathFilter.create(repo_config)
+          end
+
+          walker.setFilter(filter) if filter
+        end
+      end
+
+      def reset
+        @repo_config = nil
+        @start_commit_id = nil
+        @paths = []
+      end
+
+      def each_file_in(tree_walk)
+        if block_given?
+          while tree_walk.next
+            yield tree_walk
+          end
+        else
+          to_enum(__method__, tree_walk)
+        end
+      end
+    end
+
+  end
+end