tfs_graph 0.1.1

data/lib/tfs_graph/changeset_merge.rb

@@ -0,0 +1,57 @@
+require 'tfs_graph/entity'
+require 'tfs_graph/changeset'
+
+module TFSGraph
+  class ChangesetMerge < Entity
+
+    SCHEMA = {
+      target_version: {key: "TargetVersion", type: Integer},
+      source_version: {key: "SourceVersion", type: Integer},
+      branch: {default: nil, type: String}
+    }
+
+    act_as_entity
+
+    # overwrite the creator, and create a relationship between the
+    # two changesets requested instead of a distinct object
+    def self.create(attrs)
+      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
+
+        Related::Relationship.create :merges, target, source
+
+        # relate the branches as well
+        Related::Relationship.create :related, source.branch, target.branch
+
+        Related::Relationship.create :included, source.branch, target
+        Related::Relationship.create :included, target.branch, source
+
+        merge
+      rescue Related::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)
+    end
+
+    def get_target
+      Changeset.find(target_version)
+    end
+  end
+end

data/lib/tfs_graph/config.rb

@@ -0,0 +1,10 @@
+module TFSGraph
+  class Config
+    attr_accessor :tfs
+    attr_reader :redis
+
+    def redis=(server)
+      @redis = Related.redis = server
+    end
+  end
+end

data/lib/tfs_graph/entity.rb

@@ -0,0 +1,16 @@
+module TFSGraph
+  class Entity < Related::Node
+    def self.inherited(klass)
+      define_singleton_method :act_as_entity do
+        klass::SCHEMA.each do |key, details|
+          property key, details[:type]
+        end
+      end
+    end
+
+    private
+    def schema
+      self.class::SCHEMA
+    end
+  end
+end

data/lib/tfs_graph/graph_populator.rb

@@ -0,0 +1,35 @@
+require 'tfs_graph/project/project_store'
+require 'tfs_graph/branch/branch_store'
+require 'tfs_graph/changeset/changeset_store'
+require 'tfs_graph/changeset_merge/changeset_merge_store'
+
+require 'tfs_graph/associators/changeset_tree_creator'
+require 'tfs_graph/associators/branch_associator'
+require 'tfs_graph/branch/branch_archive_handler'
+
+require 'tfs_graph/populators'
+
+BranchNotFound = Class.new(Exception)
+
+module TFSGraph
+  class GraphPopulator
+    include Populators
+
+    class << self
+      include StoreHelpers
+
+      def populate_graph(type=Everything, *args)
+        populator = type.new *args
+        populator.populate
+      end
+
+      def incrementally_update_all
+        populate_graph(Populators::SinceLast)
+      end
+
+      def populate_all_from_time(time)
+        populate_graph(Populators::SinceDate, time)
+      end
+    end
+  end
+end

data/lib/tfs_graph/normalizer.rb

@@ -0,0 +1,30 @@
+module TFSGraph
+  class Normalizer
+    class << self
+      def normalize_many(data)
+        data.map {|item| normalize item }
+      end
+
+      def normalize(item)
+        representation = {}
+        schema.each do |key, lookup|
+
+          if lookup[:key].present?  # for keys that pull data from other sources
+            value = item.send lookup[:key]
+            value = lookup[:converter].call(value) if lookup[:converter].present?
+          else
+            value = lookup[:default]
+          end
+
+          representation[key] = value
+        end
+        representation
+      end
+
+      private
+      def schema
+        raise NoMethodError, "please define the schema in the Normalizer subclass"
+      end
+    end
+  end
+end

data/lib/tfs_graph/populators/everything.rb

@@ -0,0 +1,20 @@
+module TFSGraph
+  module Populators
+    class Everything
+      include Utilities
+
+      def populate
+        clean
+
+        collect_projects.map do |project|
+          branches = collect_branches(project)
+          branches.map {|branch| collect_changesets(branch) }
+
+          branches.each {|branch| collect_merges(branch) }
+        end
+
+        finalize
+      end
+    end
+  end
+end

data/lib/tfs_graph/populators/for_project.rb

@@ -0,0 +1,18 @@
+module TFSGraph
+  module Populators
+    class ForProject
+      include Utilities
+
+      def initialize(project)
+        @project = project
+      end
+
+      def populate
+        branches = collect_branches(@project)
+        branches.map {|branch| collect_changesets(branch) }
+
+        branches.each {|branch| collect_merges(branch) }
+      end
+    end
+  end
+end

data/lib/tfs_graph/populators/since_date.rb

@@ -0,0 +1,26 @@
+module TFSGraph
+  module Populators
+    class SinceDate
+      include Utilities
+
+      def initialize(since)
+        @since = since
+      end
+
+      def populate
+        clean
+
+        collect_projects.map do |project|
+          branches = collect_branches(project)
+          branches.map do |branch|
+            collect_changesets(branch, :cache_since_date, @since)
+          end
+
+          branches.each {|branch| collect_merges(branch) }
+        end
+
+        finalize
+      end
+    end
+  end
+end

data/lib/tfs_graph/populators/since_last.rb

@@ -0,0 +1,26 @@
+module TFSGraph
+  module Populators
+    class SinceLast
+      include Utilities
+
+      def populate
+        ProjectStore.all_cached.map do |project|
+          new_changesets = project.active_branches.map {|branch| collect_changesets branch, :cache_since_last_update}
+          new_branches = BranchStore.new(project).cache_since_last_update
+
+          new_changesets.concat new_branches.map {|branch| collect_changesets branch }
+
+          # recache and reassociate all merges for all branches.
+          # should not lead to dupes thanks to Related
+          new_branches.concat(project.branches).each do |branch|
+            collect_merges(branch)
+            BranchAssociator.associate(branch.changesets)
+          end
+        end
+
+        finalize
+      end
+
+    end
+  end
+end

data/lib/tfs_graph/populators/utilities.rb

@@ -0,0 +1,38 @@
+module TFSGraph
+  module Populators
+    module Utilities
+      include StoreHelpers
+
+      def clean
+        flush_all
+      end
+
+      def finalize
+        BranchArchiveHandler.hide_all_archives
+        mark_as_updated
+      end
+
+      def collect_projects
+        ProjectStore.cache
+      end
+
+      def collect_branches(project)
+        BranchStore.new(project).cache_all
+      end
+
+      def collect_changesets(branch, method=:cache_all, *args)
+        changesets = ChangesetStore.new(branch).send(method, *args)
+        generate_branch_tree(branch)
+        changesets.compact
+      end
+
+      def generate_branch_tree(branch)
+        ChangesetTreeCreator.to_tree branch
+      end
+
+      def collect_merges(branch)
+        ChangesetMergeStore.new(branch).cache
+      end
+    end
+  end
+end

data/lib/tfs_graph/populators.rb

@@ -0,0 +1,11 @@
+require_relative 'populators/utilities'
+
+require_relative 'populators/everything'
+require_relative 'populators/since_last'
+require_relative 'populators/since_date'
+require_relative 'populators/for_project'
+
+module TFSGraph
+  module Populators
+  end
+end

data/lib/tfs_graph/project/project_normalizer.rb

@@ -0,0 +1,12 @@
+require 'tfs_graph/project'
+require 'tfs_graph/normalizer'
+
+module TFSGraph
+  class ProjectNormalizer < Normalizer
+    class << self
+      def schema
+        Project::SCHEMA
+      end
+    end
+  end
+end

data/lib/tfs_graph/project/project_store.rb

@@ -0,0 +1,30 @@
+require 'tfs_graph/tfs_client'
+require 'tfs_graph/project/project_normalizer'
+
+module TFSGraph
+  class ProjectStore
+    extend TFSClient
+
+    class << self
+      def cache
+        projects = tfs.projects.run
+        normalized = ProjectNormalizer.normalize_many projects
+
+        normalized.map do |project_attrs|
+          project = Project.create project_attrs
+          Related::Relationship.create(:projects, Related.root, project)
+
+          project
+        end
+      end
+
+      def all_cached
+        Related.root.outgoing(:projects).options(model: Project).nodes.to_a
+      end
+
+      def find_cached(name)
+        all_cached.detect {|p| p.name == name }
+      end
+    end
+  end
+end

data/lib/tfs_graph/project.rb

@@ -0,0 +1,59 @@
+require 'tfs_graph/entity'
+
+module TFSGraph
+  class Project < Entity
+    extend Comparable
+    SCHEMA = {
+      name: {key: "Name"}
+    }
+
+    act_as_entity
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def last_change
+      branches.map {|b| b.last_changeset }
+    end
+
+    def all_activity
+      branches.map {|b| b.changesets }.flatten
+    end
+
+    def all_activity_by_date(limiter=nil)
+      raise InvalidArgument("parameter must be a Date") unless limiter.nil? || limiter.is_a?(Time)
+
+      activity = all_activity
+      activity = activity.select {|c| c.created > limiter } unless limiter.nil?
+
+      activity.group_by(&:formatted_created)
+    end
+
+    def active_branches
+      branches.reject(&:archived?)
+    end
+
+    def branches
+      branches_with_hidden.reject(&:hidden?)
+    end
+
+    def branches_with_hidden
+      outgoing(:branches).options(model: Branch).nodes.to_a
+    end
+
+    %w(master release feature).each do |type|
+      define_method "#{type}s" do
+        branches.select {|b| b.send "#{type}?" }
+      end
+
+      define_method "#{type}s_with_hidden" do
+        branches_with_hidden.select {|b| b.send "#{type}?" }
+      end
+
+      define_method "archived_#{type}s" do
+        branches.select {|b| b.send("#{type}?") && b.archived? }
+      end
+    end
+  end
+end

data/lib/tfs_graph/store_helpers.rb

@@ -0,0 +1,31 @@
+require 'time'
+
+module TFSGraph
+  module StoreHelpers
+    UPDATED_KEY = "LAST_UPDATED_ON"
+
+    # flush by key so that we only disturbe our namespace
+    def flush_all
+      redis.keys("*").each do |k|
+        redis.del k
+      end
+    end
+
+    def mark_as_updated(time=nil)
+      time ||= Time.now
+      redis.set UPDATED_KEY, time.utc
+    end
+
+    def last_updated_on
+      date = redis.get(UPDATED_KEY)
+      return Time.now unless date
+
+      Time.parse(date).localtime
+    end
+
+    private
+    def redis
+      Related.redis
+    end
+  end
+end

data/lib/tfs_graph/tfs_client.rb

@@ -0,0 +1,37 @@
+# Wraps TFS OData domain knowledge
+require 'tfs'
+
+module TFSGraph
+  module TFSClient
+    InvalidConfig = Class.new(RuntimeError)
+
+    REQUIRED_KEYS = [:endpoint, :collection, :username, :password]
+
+    # Requires a hash of settings
+    def setup(settings=TFSGraph.config.tfs)
+      raise InvalidConfig unless REQUIRED_KEYS.all? {|key| settings.keys.include? key }
+
+      TFS.configure do |c|
+        c.endpoint = endpoint(settings)
+        c.username = settings[:username]
+        c.password = settings[:password]
+        c.namespace = settings[:namespace] || "TFS"
+      end
+    end
+
+    def tfs
+      @tfs ||= begin
+        setup
+        TFS.client
+      end
+    end
+
+    def tfs=(client)
+      @tfs = client
+    end
+
+    def endpoint(settings)
+      "#{settings[:endpoint]}/#{settings[:collection]}"
+    end
+  end
+end

data/lib/tfs_graph/tfs_helpers.rb

@@ -0,0 +1,42 @@
+module TFSGraph
+  module TFSHelpers
+    def branch_base(path)
+      branch_path_to_name(path).split('-').first
+    end
+
+    # handles OData paths: $>RJR>Project>Path
+    def branch_path_to_name(path)
+      path_parts(path).last
+    end
+
+    # handles TFS server paths: $/RJR/Project/Path
+    def server_path_to_odata_path(path)
+      path.gsub "/", ">"
+    end
+
+    def odata_path_to_server_path(path)
+      path.gsub ">", "/"
+    end
+
+    def branch_project(path)
+      path_parts(path)[1]
+    end
+
+    def base_username(name)
+      name.split(/\/|\\/).last
+    end
+
+    def scrub_changeset(version)
+      version.gsub /\D/, "" unless version.nil?
+    end
+
+    private
+    def path_parts(path)
+      path.split(">")
+    end
+
+    def server_path_parts(path)
+      path.split("/")
+    end
+  end
+end

data/lib/tfs_graph/version.rb

@@ -0,0 +1,3 @@
+module TFSGraph
+  VERSION = "0.1.1"
+end

data/lib/tfs_graph.rb

@@ -0,0 +1,19 @@
+require "related"
+
+require "tfs_graph/version"
+require "tfs_graph/config"
+require 'tfs_graph/graph_populator'
+
+module TFSGraph
+  class << self
+    def config
+      return @config unless block_given?
+
+      @config ||= begin
+        config = Config.new
+        yield config
+        config
+      end
+    end
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,20 @@
+require 'tfs_graph/changeset'
+
+FactoryGirl.define do
+  factory :changeset, class: TFSGraph::Changeset do
+    comment "Doing fun things"
+    committer "John Doe"
+    created { Time.now }
+    sequence :id
+  end
+
+  factory :branch do
+    original_path "$>DefaultCollection>Project"
+    path "$>DefaultCollection>Project"
+    project "BFG"
+    name "Project"
+    root "$>DefaultCollection>Project"
+    created { Time.now }
+    type "master"
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'tfs_graph/tfs_helpers'
+
+class DemoClass; include TFSGraph::TFSHelpers; end
+
+describe TFSGraph::TFSHelpers do
+  Given(:demo) { DemoClass.new }
+  Given(:archived_path) { "$>RJR>_Branches>FAQ>RJRLibraries-FAQ" }
+  Given(:normal_path) { "$>RJR>Grizzly" }
+
+  context "can parse name of branch" do
+    When(:archived_result) { demo.branch_path_to_name(archived_path) }
+    Then { archived_result.should eq("RJRLibraries-FAQ") }
+
+    When(:normal_result) { demo.branch_path_to_name(normal_path) }
+    Then { normal_result.should eq("Grizzly") }
+  end
+
+  context "can parse down base name from a path" do
+    When(:archived_result) { demo.branch_base(archived_path) }
+    Then { archived_result.should eq("RJRLibraries") }
+
+    When(:normal_result) { demo.branch_base(normal_path) }
+    Then { normal_result.should eq("Grizzly") }
+  end
+
+  context "can parse base username from tfs" do
+    When(:fwd) { demo.base_username("BFGCOM/tmoe") }
+    Then { fwd.should eq("tmoe") }
+
+    When(:bck) { demo.base_username("BFGCOM\\tmoe") }
+    Then { bck.should eq("tmoe") }
+  end
+
+  context "can scrub out letters from changeset version" do
+    When(:version_1) { demo.scrub_changeset("C1234") }
+    Then { version_1.should eq("1234") }
+
+    When(:version_2) { demo.scrub_changeset("1234") }
+    Then { version_2.should eq("1234") }
+
+    context "does nothing if no changeset given" do
+      When(:version) { demo.scrub_changeset(nil) }
+      Then { version.should_not have_failed }
+      And { version.should == nil }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH.unshift "../lib"
+
+require 'related'
+require 'rspec/given'
+require 'vcr'
+require 'factory_girl'
+require 'pry'
+
+FactoryGirl.definition_file_paths = %w{./factories ./spec/factories}
+FactoryGirl.find_definitions
+
+require 'tfs_graph'
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+  c.hook_into :webmock
+  c.allow_http_connections_when_no_cassette = true
+  c.default_cassette_options = { record: :new_episodes }
+  c.configure_rspec_metadata!
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:each) do
+    TFSGraph.config do |c|
+      c.tfs = {
+        username: 'BFGCOM\apiservice',
+        password: "BFGservice123",
+        endpoint: "https://tfs-dev-01.bfgdev.inside/RAI"
+      }
+      c.redis = "localhost:6379/test"
+    end
+  end
+
+  config.after(:each) do
+    r = Related.redis
+    r.keys.each do |key|
+      r.del key
+    end
+  end
+end

data/tfs_graph.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tfs_graph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tfs_graph"
+  spec.version       = TFSGraph::VERSION
+  spec.authors       = ["Luke van der Hoeven"]
+  spec.email         = ["hungerandthirst@gmail.com"]
+  spec.description   = %q{A library to help cache and fetch TFS data}
+  spec.summary       = %q{Simple graph db wrapper for TFS data for Redis caching}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ruby_tfs"
+  spec.add_dependency "related"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end