tfs_graph 0.1.1 → 0.1.2

data/lib/tfs_graph/branch/branch_archive_handler.rb

@@ -7,16 +7,20 @@ module TFSGraph
     # is fairly useless, we'll hide it in favor of the "ghost" branch.
     class << self
       def hide_all_archives
-        ProjectStore.all_cached.map {|project| hide_moved_archives_for_project(project) }
+        RepositoryRegistry.project_repository.all.map {|project| hide_moved_archives_for_project(project) }
       end
 
       def hide_moved_archives_for_project(project)
-        archived = project.branches.group_by(&:path).select {|_, group| group.size > 1 }
-        archived.each do |path, group|
-          group.select(&:archived?).each(&:hide!)
-          group.reject(&:archived?).each(&:archive!)
+        project.branches.group_by(&:path).map do |path, group|
+          next unless group.size > 1
+
+          group.each do |branch|
+            branch.hide! if branch.archived?
+            branch.archive! unless branch.archived?
+          end
+
+          group
         end
-        archived
       end
     end
   end

data/lib/tfs_graph/branch/branch_store.rb

@@ -1,53 +1,40 @@
-require 'tfs_graph/tfs_client'
-require 'tfs_graph/tfs_helpers'
-require 'tfs_graph/store_helpers'
+require 'tfs_graph/abstract_store'
 
 require 'tfs_graph/branch/branch_normalizer'
 require 'tfs_graph/branch'
 
 module TFSGraph
-  class BranchStore
-    include TFSClient
-    include TFSHelpers
-    include StoreHelpers
-
+  class BranchStore < AbstractStore
     LIMIT = 1000
 
     def initialize(project)
       @project = project
     end
 
-    def cache_all
-      persist(all)
+    def fetch_since_last_update
+      fetch_since_date(@project.last_updated.iso8601)
     end
 
-    def cache_since_last_update
-      persist since_last_update
+    def fetch_since_date(date)
+      normalize root_query.where("DateCreated gt DateTime'#{date}'").run
     end
 
-    def all
-      normalize root_query.run
-    end
+    def cache(attrs)
+      branch = RepositoryRegistry.branch_repository.build attrs
+
+      # add_branch action runs save! on branch
+      @project.add_branch(branch)
 
-    def since_last_update
-      normalize root_query.where("DateCreated gt DateTime'#{last_updated_on.iso8601}'").run
+      branch
     end
 
     private
     def root_query
-      tfs.projects(@project.name).branches.limit(LIMIT)
+      tfs.projects(@project.name).branches.order_by('DateCreated desc').limit(LIMIT)
     end
 
     def normalize(branches)
       BranchNormalizer.normalize_many branches
     end
-
-    def persist(branches)
-      branches.map do |branch_attrs|
-        branch = Branch.create branch_attrs
-        Related::Relationship.create(:branches, @project, branch)
-        branch
-      end
-    end
   end
 end

data/lib/tfs_graph/changeset.rb

@@ -1,21 +1,20 @@
-require 'tfs_graph/entity'
+require 'tfs_graph/persistable_entity'
 require 'tfs_graph/tfs_helpers'
 
 # FIXME: DRY along side the Branch class
 module TFSGraph
-  class Changeset < Entity
+  class Changeset < PersistableEntity
     extend TFSHelpers
-    extend Comparable
 
     SCHEMA = {
       comment: {key: "Comment", type: String},
       committer: {key: "Committer", converter: ->(name) { base_username(name) }, type: String},
-      created: {key: "CreationDate", type: DateTime},
+      created: {key: "CreationDate", type: Time},
       id: {key: "Id", type: Integer},
       branch_path: {type: String, default: nil},
-      tags: {type: Array, default: []},
-      parent: {type: Integer, default: nil},
-      merge_parent: {type: Integer, default: nil}
+      # tags: {type: Array, default: []},
+      parent: {type: Integer, default: 0},
+      merge_parent: {type: Integer, default: 0}
     }
 
     act_as_entity
@@ -24,14 +23,45 @@ module TFSGraph
       id <=> other.id
     end
 
+    # override for the & (intersect) operator
+    def eql?(other)
+      other.is_a?(self.class) && other == self
+    end
+
+    def hash
+      @internal_id.hash
+    end
+
+    def id
+      @id.to_i unless @id.nil?
+    end
+
+    def merge?
+      !base? && @merge_parent != 0
+    end
+
+    def base?
+      @parent == 0 || @parent == @merge_parent
+    end
+
+    def created
+      return nil unless @created
+      return @created unless @created.is_a? String
+      @created = Time.parse @created
+    end
+
+    def add_child(changeset)
+      @repo.relate(:child, self.db_object, changeset.db_object)
+    end
+
     def next
-      child = outgoing(:child).options(model: self.class).nodes.to_a.first
+      child = @repo.get_nodes(db_object, :outgoing, :child, self.class).first
       raise StopIteration unless child
       child
     end
 
     def branch
-      incoming(:changesets).options(model: Branch).nodes.to_a.first
+      @repo.get_nodes(db_object, :incoming, :changesets, Branch).first
     end
 
     def formatted_created
@@ -39,8 +69,9 @@ module TFSGraph
     end
 
     %w(merges merged).each do |type|
+      directon = (type == "merges") ? :outgoing : :incoming
       define_method type do
-        get_merges_for outgoing(type.to_sym)
+        @repo.get_nodes(db_object, directon, :merges, self.class)
       end
 
       define_method "#{type}_ids" do
@@ -49,23 +80,13 @@ module TFSGraph
     end
 
     def as_json(options={})
-      options.merge! methods: [:merges_ids, :merged_ids]
-      super
-    end
+      results = super
 
-    def set_merging_to
-      into = merged.max
-      self.merge_parent = into.id if into
-    end
-
-    def set_merging_from
-      from = merges.max
-      self.merge_parent = from.id if from
-    end
+      [:merges_ids, :merged_ids].each do |key|
+        results[key] = self.send key
+      end
 
-    private
-    def get_merges_for(merge)
-      merge.options(model: self.class).nodes.to_a
+      results
     end
   end
 end

data/lib/tfs_graph/changeset/changeset_normalizer.rb

@@ -10,6 +10,7 @@ module TFSGraph
       def normalize(item, branch)
         item = super(item)
         item[:branch_path] = branch
+        item[:comment] = item[:comment].gsub(/\\+/, "|")
         item
       end
 

data/lib/tfs_graph/changeset/changeset_store.rb

@@ -1,65 +1,42 @@
-require 'tfs_graph/tfs_client'
-require 'tfs_graph/store_helpers'
+require 'tfs_graph/abstract_store'
 
 require 'tfs_graph/changeset/changeset_normalizer'
 require 'tfs_graph/changeset'
+
 # Wraps domain knowledge of changeset TFS access
 
 module TFSGraph
-  class ChangesetStore
-    include TFSClient
-    include StoreHelpers
-
+  class ChangesetStore < AbstractStore
     LIMIT = 10000
 
     def initialize(branch)
       @branch = branch
     end
 
-    def cache_all
-      persist all
+    def fetch_since_last_update
+      fetch_since_date(@branch.last_updated.iso8601)
     end
 
-    def cache_since_last_update
-      persist since_last_update
-    end
-
-    def cache_since_date(start)
-      persist since_date(start)
+    def fetch_since_date(date)
+      normalize root_query.where("CreationDate gt DateTime'#{date}'").run
     end
 
-    def all
-      normalize root_query.run
-    end
+    def cache(attrs)
+      changeset = RepositoryRegistry.changeset_repository.build attrs
 
-    def since_date(date)
-      normalize root_query.where("CreationDate gt DateTime'#{date}'").run
-    end
+      # add_changeset action runs save! on changeset
+      @branch.add_changeset changeset
 
-    def since_last_update
-      since_date(last_updated_on.iso8601)
+      changeset
     end
 
     private
     def root_query
-      tfs.branches(@branch.path).changesets.limit(LIMIT)
+      tfs.branches(@branch.path).changesets.order_by("Id asc").limit(LIMIT)
     end
 
     def normalize(changesets)
       ChangesetNormalizer.normalize_many changesets, @branch.path
     end
-
-    def persist(changesets)
-      changesets.map do |attrs|
-        begin
-          changeset = Changeset.create attrs
-          Related::Relationship.create :changesets, @branch, changeset
-          changeset
-        rescue Related::ValidationsFailed => ex
-          # puts ex.message
-          next
-        end
-      end.compact
-    end
   end
 end

data/lib/tfs_graph/changeset_merge.rb

@@ -1,4 +1,3 @@
-require 'tfs_graph/entity'
 require 'tfs_graph/changeset'
 
 module TFSGraph
@@ -6,8 +5,7 @@ module TFSGraph
 
     SCHEMA = {
       target_version: {key: "TargetVersion", type: Integer},
-      source_version: {key: "SourceVersion", type: Integer},
-      branch: {default: nil, type: String}
+      source_version: {key: "SourceVersion", type: Integer}
     }
 
     act_as_entity
@@ -18,40 +16,44 @@ module TFSGraph
       begin
         merge = new(attrs)
 
-        # this will throw an error if one of the relations is not found
-        # this is the desired condition as it will throw out the merge if there aren't two endpoints found
         target, source = merge.get_relations
+        return nil unless target.persisted? and source.persisted?
 
-        Related::Relationship.create :merges, target, source
+        merge.join :merges, target, source
 
         # relate the branches as well
-        Related::Relationship.create :related, source.branch, target.branch
+        if source.branch && target.branch
+          merge.join :related, source.branch, target.branch
 
-        Related::Relationship.create :included, source.branch, target
-        Related::Relationship.create :included, target.branch, source
+          merge.join :included, source.branch, target
+          merge.join :included, target.branch, source
+        end
 
         merge
-      rescue Related::NotFound => ex
+      rescue TFSGraph::Repository::NotFound => ex
         # puts "Could not find a changeset to merge with: #{ex.message}"
-      rescue Related::ValidationsFailed => ex
-        # puts "Couldn't create relationship for #{merge.source_version} to #{merge.target_version}"
       end
     end
 
-    def save
-      # nothing, no need to save
-    end
-
     def get_relations
       return get_target, get_source
     end
 
     def get_source
-      Changeset.find(source_version)
+      repo.find(source_version)
     end
 
     def get_target
-      Changeset.find(target_version)
+      repo.find(target_version)
+    end
+
+    def join(relation, target, source)
+      repo.relate(relation, target.db_object, source.db_object)
+    end
+
+    private
+    def repo
+      @repo ||= RepositoryRegistry.changeset_repository
     end
   end
 end

data/lib/tfs_graph/changeset_merge/changeset_merge_store.rb

@@ -1,24 +1,27 @@
-require 'tfs_graph/tfs_client'
+require 'tfs_graph/abstract_store'
+
 require 'tfs_graph/changeset_merge/changeset_merge_normalizer'
 require 'tfs_graph/changeset_merge'
 
 module TFSGraph
-  class ChangesetMergeStore
-    include TFSClient
-
+  class ChangesetMergeStore < AbstractStore
     LIMIT = 10000
 
     def initialize(branch)
       @branch = branch
     end
 
-    def cache
-      merges = tfs.branches(@branch.path).changesetmerges.limit(LIMIT).run
-      normalized = ChangesetMergeNormalizer.normalize_many merges, @branch
+    def cache(attrs)
+      ChangesetMerge.create(attrs)
+    end
+
+    private
+    def root_query
+      tfs.branches(@branch.path).changesetmerges.limit(LIMIT)
+    end
 
-      normalized.map do |attrs|
-        ChangesetMerge.create(attrs)
-      end.compact
+    def normalize(merges)
+      ChangesetMergeNormalizer.normalize_many merges, @branch
     end
   end
 end

data/lib/tfs_graph/config.rb

@@ -1,10 +1,18 @@
 module TFSGraph
   class Config
-    attr_accessor :tfs
-    attr_reader :redis
+    attr_accessor :tfs, :graph
 
-    def redis=(server)
-      @redis = Related.redis = server
+    def redis(url: url, namespace: namespace)
+      ServerRegistry.register do |r|
+        r.redis url: url, namespace: namespace
+      end
+    end
+
+    def graph(repo_type: nil)
+      raise ArgumentError unless repo_type
+      RepositoryRegistry.register do |r|
+        r.type repo_type
+      end
     end
   end
 end

data/lib/tfs_graph/entity.rb

@@ -1,16 +1,44 @@
 module TFSGraph
-  class Entity < Related::Node
+  class Entity
     def self.inherited(klass)
       define_singleton_method :act_as_entity do
-        klass::SCHEMA.each do |key, details|
-          property key, details[:type]
-        end
+        attr_accessor *klass::SCHEMA.keys
       end
     end
 
-    private
+    def initialize(args)
+      schema.each do |key, details|
+        value = (args[key] || details[:default])
+
+        value = ressurect_time(value) if details[:type] == Time
+
+        send "#{key}=", value
+      end
+    end
+
+    def to_hash
+      hash = {}
+      schema.keys.each do |key|
+        hash[key] = send key
+      end
+
+      hash.each do |k,v|
+        next unless v.is_a? Time
+        hash[k] = v.utc.to_i
+      end
+
+      hash
+    end
+    alias_method :attributes, :to_hash
+
     def schema
       self.class::SCHEMA
     end
+
+    private
+    def ressurect_time(time)
+      return time if (time.is_a?(Time) || time.nil?)
+      Time::at time.to_i
+    end
   end
-end
+end