tfs_graph 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 305a88a142479775b0507af876a4e432b5069c62
+  data.tar.gz: 82b14fc50dd7d1b0fbb76bde73d861c4e6e6fef2
+SHA512:
+  metadata.gz: 383e2e25094ffc75ef1ec0a8b42fb2c8d3cc5c34198a6149ed9a633d2249f0bfdac5ae36040d70690fbe677afe2d95a8ef3950093b32c6b5b0cf4fa249bf8c65
+  data.tar.gz: 08b56fcb8b084152b282362434a4e692e19e967b5f626e767426b0cf1296d9b93431ba0fc496f1b02b9e7c55988cb6b23e67cf44360a5f160d4dd46ea875d953

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+spec/fixtures
+test/tmp
+test/version_tmp
+tmp
+
+bfg.rb

data/.ruby-gemset

@@ -0,0 +1 @@
+tfs_graph

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tfs_graph.gemspec
+gemspec
+
+gem "related", git: "https://github.com/plukevdh/related.git", branch: "preserve_external_ids"
+
+group :test do
+  gem 'rspec'
+  gem 'rspec-given'
+  gem 'webmock'
+  gem 'vcr'
+  gem 'factory_girl'
+end
+
+group :test, :development do
+  gem "pry"
+  gem 'benchmark-ips'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Luke van der Hoeven
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# TFSGraph
+
+This is a nice little library to tie together TFS data (using the TFS OData API via ruby_tfs) Related, a super-lightweight faux-graph DB implementation built on top of Redis.
+
+To initially map your TFS data, you can run the GraphPopulator.
+
+```ruby
+include TFSGraph
+
+GraphPopulator.populate_all
+```
+
+This will scrape and dump all of the TFS data into Redis and build the initial set of relationships. From there, you can traverse the data starting from the projects and digging in deeper. The *Store (ProjectStore/BranchStore) classes can help make the initial queries against this.
+
+```ruby
+# Get all the branch objects
+projects = ProjectStore.all_cached
+
+# Get all the branches for a project
+branches = projects.branches
+
+# Gett all the changesets from the branches
+changesets = branches.map do |branch|
+  branch.changesets
+end
+
+# Get all the changesets that have merged with this changeset
+changesets.first.merges
+
+# Or get all the changesets that this one has merged into
+changesets.first.merged
+
+
+# Get all the "master" branches
+projects.roots
+```
+
+There are plenty more relationships to traverse an each object type (Project/Branch/Changeset) has its own set of properties.
+
+- Project
+  - name
+
+- Branch
+  - original_path
+  - path
+  - project
+  - name
+  - root
+  - created
+  - type
+  - archived
+
+- Changeset
+  - comment
+  - committer
+  - created
+  - id
+  - branch_path
+  - tags
+  - parent
+  - merge_parent
+
+Changesets are also enumerable. So you can do things like
+
+```ruby
+child = changeset.next
+child.next # keep `next`ing until StopIteration is raised
+
+
+# loops also work with this:
+
+loop do
+  child = changeset.next
+  # do somethign with child
+
+  changeset = child
+end
+```
+
+This is not a subclass of the enumerator class, so it won't behave the same as other enumerable classes.
+
+
+## Requirements
+
+You will need Redis installed. You can configure like so:
+
+```ruby
+TFSGraph.config do |c|
+  c.tfs = {
+    username: "me",
+    password: "lame",
+    endpoint: "https://my-odata-endpoint/Collection"
+  },
+  c.redis = "localhost:6379/Namespace"
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tfs_graph'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tfs_graph
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/tfs_graph/associators/branch_associator.rb

@@ -0,0 +1,25 @@
+module TFSGraph
+  class BranchAssociator
+    class << self
+
+      # sets up parent/child relationships
+      def associate_groups(sets_by_branch)
+        sets_by_branch.each do |group|
+          associate(group)
+        end
+      end
+
+      def associate(changesets)
+        return if changesets.empty?
+
+        change = changesets.first
+        root = change.merges.max
+
+        return if root.nil?
+
+        change.parent = root.id
+        change.save
+      end
+    end
+  end
+end

data/lib/tfs_graph/associators/changeset_tree_creator.rb

@@ -0,0 +1,19 @@
+module TFSGraph
+  class ChangesetTreeCreator
+    class << self
+      def to_tree(branch)
+        changesets = branch.changesets
+        changesets.each.with_index do |changeset, i|
+          parent = (i == 0) ? branch : changesets[i-1]
+
+          if Changeset.find parent.id
+            changeset.parent = parent.id
+            changeset.save
+          end
+
+          Related::Relationship.create :child, parent, changeset
+        end
+      end
+    end
+  end
+end

data/lib/tfs_graph/branch/branch_archive_handler.rb

@@ -0,0 +1,23 @@
+module TFSGraph
+  class BranchArchiveHandler
+    # Archives == moving a branch from root to an archive folder
+    # The actual history is attached to the old branch path in TFS,
+    # but now we have a "ghost" branch (with the important history attached)
+    # and an "archived" branch (by rename in TFS). Since the "archived" branch
+    # 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) }
+      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!)
+        end
+        archived
+      end
+    end
+  end
+end

data/lib/tfs_graph/branch/branch_normalizer.rb

@@ -0,0 +1,11 @@
+require 'tfs_graph/normalizer'
+
+module TFSGraph
+  class BranchNormalizer < Normalizer
+    class << self
+      def schema
+        Branch::SCHEMA
+      end
+    end
+  end
+end

data/lib/tfs_graph/branch/branch_store.rb

@@ -0,0 +1,53 @@
+require 'tfs_graph/tfs_client'
+require 'tfs_graph/tfs_helpers'
+require 'tfs_graph/store_helpers'
+
+require 'tfs_graph/branch/branch_normalizer'
+require 'tfs_graph/branch'
+
+module TFSGraph
+  class BranchStore
+    include TFSClient
+    include TFSHelpers
+    include StoreHelpers
+
+    LIMIT = 1000
+
+    def initialize(project)
+      @project = project
+    end
+
+    def cache_all
+      persist(all)
+    end
+
+    def cache_since_last_update
+      persist since_last_update
+    end
+
+    def all
+      normalize root_query.run
+    end
+
+    def since_last_update
+      normalize root_query.where("DateCreated gt DateTime'#{last_updated_on.iso8601}'").run
+    end
+
+    private
+    def root_query
+      tfs.projects(@project.name).branches.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/branch.rb

@@ -0,0 +1,157 @@
+require 'tfs_graph/entity'
+require 'tfs_graph/tfs_helpers'
+
+module TFSGraph
+  class Branch < Entity
+    extend TFSHelpers
+    extend Comparable
+
+    SCHEMA = {
+      original_path: {key: "Path", type: String},
+      path: {key: "Path", converter: ->(path) { repath_archive(path) }, type: String},
+      project: {converter: ->(path) { branch_project(path) }, key: "Path", type: String},
+      name: {converter: ->(path) { branch_path_to_name(path) }, key: "Path", type: String},
+      root: {converter: ->(path) { repath_archive(server_path_to_odata_path(path)) if path }, key: "ParentBranch", type: String},
+      created: {key: "DateCreated", type: DateTime},
+      type: {default: "Feature", type: Integer},
+      archived: {default: false, type: String},
+      hidden: {default: false, type: String}
+    }
+
+    BRANCH_TYPES = [
+      :master,
+      :release,
+      :feature
+    ]
+
+    ARCHIVED_FLAGS = ["Archive"]
+    RELEASE_MATCHER = /^(.+)-r(\d+)-(\d+)$/i
+
+    act_as_entity
+
+    before_create :detect_type, :detect_archived
+
+    BRANCH_TYPES.each do |t|
+      define_method "#{t}?".to_sym do
+        BRANCH_TYPES.at(type) == t
+      end
+    end
+
+    def archived?
+      archived.to_s == "true"
+    end
+
+    def hidden?
+      hidden.to_s == "true"
+    end
+
+    def named_type
+      BRANCH_TYPES[type]
+    end
+
+    def hide!
+      self.hidden = true
+      save
+    end
+
+    def archive!
+      self.archived = true
+      save
+    end
+
+    def rootless?
+      !master? && root.empty?
+    end
+
+    def type_index(name)
+      BRANCH_TYPES.index(name.to_sym)
+    end
+
+    # returns a branch
+    def absolute_root
+      @absolute_root ||= begin
+        item = self
+        proj = ProjectStore.find_cached project
+
+        until(item.master?) do
+          item = proj.branches.detect {|branch| branch.path == item.root }
+        end
+
+        item
+      end
+    end
+
+    def branch?
+      !master?
+    end
+
+    # branches this one touches or is touched
+    def related_branches
+      incoming(:related).options(model: Branch).nodes.to_a.map &:id
+    end
+
+    def changesets
+      outgoing(:changesets).options(model: Changeset).nodes.to_a
+    end
+
+    def contributors
+      changesets.group_by(&:committer)
+    end
+
+    def root_changeset
+      @root ||= outgoing(:child).options(model: Changeset).nodes.to_a.first
+    end
+
+    def last_changeset
+      changesets.last
+    end
+
+    def ahead_of_master
+      return 0 unless absolute_root
+      self.outgoing(:changesets)
+        .diff(absolute_root.outgoing(:included)
+          .intersect(self.outgoing(:changesets)))
+        .to_a.count
+    end
+
+    # gets the set of changesets that exist in both root and self
+    # then gets a diff of that set and the root.
+    def behind_master
+      return 0 unless absolute_root
+      absolute_root.outgoing(:changesets)
+        .diff(self.outgoing(:included)
+          .intersect(absolute_root.outgoing(:changesets)))
+        .to_a.count
+    end
+
+    def <=>(other)
+      path <=> other.path
+    end
+
+    def as_json(options={})
+      options.merge! methods: :related_branches
+      super
+    end
+
+    private
+    def detect_type
+      return self.type = type_index(:master) if (root.empty?)
+      return self.type = type_index(:release) if !(name =~ RELEASE_MATCHER).nil?
+      self.type = type_index(:feature)
+      nil
+    end
+
+    def detect_archived
+      self.archived = ARCHIVED_FLAGS.any? {|flag| original_path.include? flag }
+      nil
+    end
+
+    def self.repath_archive(path)
+      path = path.dup
+      return path unless ARCHIVED_FLAGS.any? {|flag| path.include? flag }
+
+      ARCHIVED_FLAGS.each {|flag| path.gsub!(/#{flag}>?(?:.*)>/, "") }
+      path
+    end
+  end
+end

data/lib/tfs_graph/changeset/changeset_normalizer.rb

@@ -0,0 +1,21 @@
+require 'tfs_graph/normalizer'
+
+module TFSGraph
+  class ChangesetNormalizer < Normalizer
+    class << self
+      def normalize_many(data, branch)
+        changesets = data.map {|item| normalize(item, branch) }
+      end
+
+      def normalize(item, branch)
+        item = super(item)
+        item[:branch_path] = branch
+        item
+      end
+
+      def schema
+        Changeset::SCHEMA
+      end
+    end
+  end
+end

data/lib/tfs_graph/changeset/changeset_store.rb

@@ -0,0 +1,65 @@
+require 'tfs_graph/tfs_client'
+require 'tfs_graph/store_helpers'
+
+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
+
+    LIMIT = 10000
+
+    def initialize(branch)
+      @branch = branch
+    end
+
+    def cache_all
+      persist all
+    end
+
+    def cache_since_last_update
+      persist since_last_update
+    end
+
+    def cache_since_date(start)
+      persist since_date(start)
+    end
+
+    def all
+      normalize root_query.run
+    end
+
+    def since_date(date)
+      normalize root_query.where("CreationDate gt DateTime'#{date}'").run
+    end
+
+    def since_last_update
+      since_date(last_updated_on.iso8601)
+    end
+
+    private
+    def root_query
+      tfs.branches(@branch.path).changesets.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.rb

@@ -0,0 +1,71 @@
+require 'tfs_graph/entity'
+require 'tfs_graph/tfs_helpers'
+
+# FIXME: DRY along side the Branch class
+module TFSGraph
+  class Changeset < Entity
+    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},
+      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}
+    }
+
+    act_as_entity
+
+    def <=>(other)
+      id <=> other.id
+    end
+
+    def next
+      child = outgoing(:child).options(model: self.class).nodes.to_a.first
+      raise StopIteration unless child
+      child
+    end
+
+    def branch
+      incoming(:changesets).options(model: Branch).nodes.to_a.first
+    end
+
+    def formatted_created
+      created.strftime("%m/%d/%Y")
+    end
+
+    %w(merges merged).each do |type|
+      define_method type do
+        get_merges_for outgoing(type.to_sym)
+      end
+
+      define_method "#{type}_ids" do
+        send(type).map &:id
+      end
+    end
+
+    def as_json(options={})
+      options.merge! methods: [:merges_ids, :merged_ids]
+      super
+    end
+
+    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
+
+    private
+    def get_merges_for(merge)
+      merge.options(model: self.class).nodes.to_a
+    end
+  end
+end

data/lib/tfs_graph/changeset_merge/changeset_merge_normalizer.rb

@@ -0,0 +1,21 @@
+require 'tfs_graph/normalizer'
+
+module TFSGraph
+  class ChangesetMergeNormalizer < Normalizer
+    class << self
+      def normalize_many(data, branch)
+        changesets = data.map {|item| normalize(item, branch) }
+      end
+
+      def normalize(item, branch)
+        item = super(item)
+        item[:branch] = branch.name
+        item
+      end
+
+      def schema
+        ChangesetMerge::SCHEMA
+      end
+    end
+  end
+end

data/lib/tfs_graph/changeset_merge/changeset_merge_store.rb

@@ -0,0 +1,24 @@
+require 'tfs_graph/tfs_client'
+require 'tfs_graph/changeset_merge/changeset_merge_normalizer'
+require 'tfs_graph/changeset_merge'
+
+module TFSGraph
+  class ChangesetMergeStore
+    include TFSClient
+
+    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
+
+      normalized.map do |attrs|
+        ChangesetMerge.create(attrs)
+      end.compact
+    end
+  end
+end