pair_see 0.1.5 → 0.1.6

data/lib/pair_see/log_line_parse.rb

@@ -0,0 +1,24 @@
+module PairSee
+  class LogLineParse
+    require_relative 'log_lines'
+    require 'git'
+
+    @@maximum_commits_to_parse = 9999
+    attr_reader :log_lines
+
+    def initialize(roots, date_string)
+      @log_lines = _parse(date_string, roots)
+    end
+
+    def _parse(date_string, roots)
+      lines = []
+      roots.each do |root|
+        g = Git.open(root)
+        lines << g.log(@@maximum_commits_to_parse).since(date_string).map do |l|
+          LogLine.new("#{l.date} #{l.message}")
+        end
+      end
+      LogLines.new(lines.flatten)
+    end
+  end
+end

data/lib/pair_see/log_lines.rb

@@ -10,11 +10,11 @@ module PairSee
     end
 
     def each(&block)
-      lines.each &block
+      @lines.each &block
     end
 
     def last
-      lines.last
+      @lines.last
     end
 
     def active?(person)
@@ -24,21 +24,17 @@ module PairSee
     end
 
     def commits_for_pair(person1, person2)
-      select {|log_line| log_line.authored_by?(person1, person2)}
+      select { |log_line| log_line.authored_by?(person1, person2) }
     end
 
-    def commits_not_by_known_pair(devs)
-      reject {|log_line| log_line.by_any? devs}
+    def commits_not_by_known_person(devs)
+      reject { |log_line| log_line.by_any? devs }
     end
 
     def solo_commits(people, person)
       select do |log_line|
-        log_line.authored_by?(person) && (people - [person]).none? {|single_person| log_line.authored_by?(single_person)}
+        log_line.authored_by?(person) && (people - [person]).none? { |single_person| log_line.authored_by?(single_person) }
       end
     end
-
-    private
-
-    attr_reader :lines
   end
 end

data/lib/pair_see/{combo.rb → pair_commit_count.rb}

@@ -1,9 +1,10 @@
 module PairSee
-  class Combo
+  class PairCommitCount
     attr_reader :count, :devs
 
     def initialize(count, *devs)
-      @count, @devs = count, devs
+      @count = count
+      @devs = devs
     end
 
     def to_s

data/lib/pair_see/pair_recency.rb

@@ -0,0 +1,27 @@
+module PairSee
+  class PairRecency
+    def initialize(log_lines, card_prefixes, people)
+      @log_lines = log_lines
+      @card_prefixes = card_prefixes
+      @people = people
+    end
+
+    def pair_recency
+      pairing_events = @people.map do |current_person|
+        my_commits = @log_lines.select { |ll| ll.authored_by?(current_person) }
+
+        most_recent_commits = {}
+        @people.map do |pair|
+          my_commits.each do |ll|
+            if pair.display_name != current_person.display_name && ll.authored_by?(pair)
+              most_recent_commits[pair] = [ll, pair] # TODO: make [ll, pair] and object? or make ll know devs in ll?
+            end
+          end
+        end
+        PairingEvent.new(current_person, most_recent_commits)
+      end
+
+      pairing_events.map(&:pretty) # TODO: make an object which extends Enum and holds pairing events
+    end
+  end
+end

data/lib/pair_see/pairing_event.rb

@@ -0,0 +1,24 @@
+module PairSee
+  class PairingEvent
+    def initialize(current_person, most_recent_commits)
+      @current_person = current_person
+      @most_recent_commits = most_recent_commits
+    end
+
+    def pretty
+      @most_recent_commits.sort_by { |_pair, tuple| tuple.first.date }.map do |_pair, tuple|
+        "#{@current_person}, #{tuple.last}: #{tuple.first.date}"
+      end + _pretty_spacing
+    end
+
+    def person
+      @current_person
+    end
+
+    private
+
+    def _pretty_spacing
+      ['']
+    end
+  end
+end

data/lib/pair_see/person.rb

@@ -1,6 +1,5 @@
 module PairSee
   class Person
-
     attr_reader :display_name
     attr_reader :names
 

data/lib/pair_see/seer.rb

@@ -1,128 +1,52 @@
 module PairSee
   class Seer
-    require 'yamler'
-    require_relative 'combo'
-    require_relative 'date_combo'
-    require_relative 'log_lines'
-    require_relative 'card'
-    require_relative 'cards_per_person'
-    require_relative 'active_devs'
+    require_relative 'too_much_stuff'
 
-    attr_reader :log_lines, :devs, :dev_pairs, :card_prefixes
-    @@maximum_commits_to_parse = 9999
+    attr_reader :seer
 
     def initialize(options)
-      @log_lines = _lines_from(options[:repo_locations], options[:after_date])
-      @sub_seer = CardsPerPerson.new(@log_lines, options[:card_prefix], options[:names])
-      @active_devs = ActiveDevs.new(@log_lines, options).devs
-      @devs = @sub_seer.devs
-      @card_prefixes = options[:card_prefix]
-      @dev_pairs = devs.combination(2)
+      @repo_locations = options[:repo_locations]
+      @after_date = options[:after_date]
+      @card_prefix = options[:card_prefix]
+      @names = options[:names]
+      @seer = PairSee::TooMuchStuff.new(options)
+      @log_lines = LogLineParse.new(@repo_locations, @after_date).log_lines
     end
 
-    def cards_per_person
-      @sub_seer.cards_per_person
-    end
-
-    def _lines_from(roots, date_string)
-      lines = []
-      roots.each {|root|
-        g = Git.open(root)
-        lines << g.log(@@maximum_commits_to_parse).since(date_string).map do |l|
-          LogLine.new("#{l.date} #{l.message}")
-        end
-      }
-      LogLines.new(lines.flatten)
-    end
-
-    def pretty_card_data
-      card_data(card_prefixes).map do |card|
-        card.pretty unless card.nil?
-      end
-    end
-
-    def card_data(card_prefixes)
-      card_prefixes.map do |card_prefix|
-        card_numbers(card_prefix).map do |card_name|
-          commits = commits_on_card(card_name)
-          Card.new(card_name, commits.count, commits.first.date, commits.last.date)
-        end
-      end.flatten.sort_by(&:duration).reverse
-    end
-
-    def commits_on_card(card_name)
-      log_lines.select {|line| line.contains_card_name?(card_name)}
-    end
-
-    def card_numbers(card_prefix)
-      log_lines.select do |line|
-        line.contains_card?(card_prefix)
-      end.map do |line|
-        line.card_name([card_prefix])
-      end.uniq.compact
+    def commits_not_by_known_pair
+      seer.commits_not_by_known_person
     end
 
-    def get_card_prefix(config_file)
-      config = YAML.load_file(config_file)
-      config['card_prefix']
+    def all_most_recent_commits
+      seer.all_most_recent_commits
     end
 
-    def active_devs(config_file)
-      @active_devs
+    def recommended_pairings
+      seer.recommended_pairings
     end
 
-    def pair_commits
-      dev_pairs.map do |person1, person2|
-        Combo.new(commits_for_pair(person1, person2).count, person1, person2)
-      end
+    def pretty_card_data
+      seer.pretty_card_data
     end
 
-    def solo_commits
-      devs.map do |dev|
-        Combo.new(log_lines.solo_commits(devs, dev).count, dev)
-      end
+    def pretty_card_data_by_commits
+      seer.pretty_card_data_by_commits
     end
 
     def all_commits
-      (pair_commits + solo_commits).sort_by(&:count).reject(&:empty?).map(&:to_s)
-    end
-
-    def commits_for_pair(person1, person2)
-      log_lines.commits_for_pair person1, person2
-    end
-
-    def commits_not_by_known_pair
-      log_lines.commits_not_by_known_pair devs
+      seer.all_commits
     end
 
-    def most_recent_commit_date(person1, person2)
-      recent_commit = commits_for_pair(person1, person2).sort_by(&:date).first
-      recent_commit ? recent_commit.date : nil
-    end
-
-    def all_most_recent_commits
-      dev_pairs.map do |person1, person2|
-        DateCombo.new(most_recent_commit_date(person1, person2), person1, person2)
-      end.sort.reverse.map &:to_s
-    end
-
-    def recommended_pairings
-      should_pair = unpaired_in_range
-      should_pair.empty? ? [least_recent_pair] : should_pair
+    def cards_per_person
+      CardsPerPerson.new(@log_lines, @card_prefix, @names).cards_per_person
     end
 
-    def least_recent_pair
-      devs.select do |person|
-        person.names.any? {|name| log_lines.last.line.match(name)}
-      end.map(&:display_name).join(', ')
+    def knowledge_debt
+      KnowledgeDebt.new(@log_lines, @card_prefix, @names).knowledge_debt
     end
 
-    def unpaired_in_range
-      dev_pairs.select do |person1, person2|
-        most_recent_commit_date(person1, person2).nil?
-      end.map do |person1, person2|
-        "#{person1}, #{person2}"
-      end
+    def pair_recency
+      PairRecency.new(@log_lines, @card_prefix, @names).pair_recency
     end
   end
 end

data/lib/pair_see/too_much_stuff.rb

@@ -0,0 +1,157 @@
+require 'pry'
+module PairSee
+  class TooMuchStuff
+    require 'yamler'
+    require_relative 'pair_commit_count'
+    require_relative 'date_combo'
+    require_relative 'log_lines'
+    require_relative 'log_line_parse'
+    require_relative 'card'
+    require_relative 'cards_per_person'
+    require_relative 'active_devs'
+
+    def initialize(options)
+      @log_lines = LogLineParse.new(options[:repo_locations], options[:after_date]).log_lines
+      @active_devs = ActiveDevs.new(@log_lines, options[:names]).devs
+
+      cards_per_person = CardsPerPerson.new(@log_lines, options[:card_prefix], options[:names])
+      @devs = cards_per_person.people
+      @dev_pairs = cards_per_person.dev_pairs
+
+      @card_prefixes = options[:card_prefix]
+    end
+
+    def pretty_card_data
+      card_data(@card_prefixes).map do |card|
+        card&.pretty
+      end
+    end
+
+    def pretty_card_data_by_commits
+      card_data(@card_prefixes).compact.sort_by.sort_by(&:number_of_commits).reverse.map(&:pretty)
+    end
+
+    def card_data(card_prefixes)
+      card_prefixes.map do |card_prefix|
+        card_numbers(card_prefix).map do |card_name|
+          Card.new(card_name, commits_on_card(card_name).sort_by(&:date))
+        end
+      end.flatten.sort_by(&:duration).reverse
+    end
+
+    def commits_on_card(card_name)
+      @log_lines.select { |line| line.contains_card_name?(card_name) }
+    end
+
+    def card_numbers(card_prefix)
+      @log_lines.select do |line|
+        line.contains_card?(card_prefix)
+      end.map do |line|
+        line.card_name([card_prefix])
+      end.uniq.compact
+    end
+
+    def get_card_prefix(config_file)
+      config = YAML.load_file(config_file)
+      config['card_prefix']
+    end
+
+    def pair_commits
+      @dev_pairs.map do |person1, person2|
+        log_lines_commits_for_pair = @log_lines.commits_for_pair person1, person2
+        PairCommitCount.new(log_lines_commits_for_pair.count, person1, person2)
+      end
+    end
+
+    def solo_commits
+      @devs.map do |dev|
+        PairCommitCount.new(@log_lines.solo_commits(@devs, dev).count, dev)
+      end
+    end
+
+    def all_commits
+      pairs_result = Hash[@dev_pairs.map { |k, v| [names_key(k, v), 0] }]
+      solos_result = Hash[@devs.map { |k| [k.display_name, 0] }]
+      result = pairs_result.merge solos_result
+
+      @log_lines.each do |ll|
+        result = method_name(ll, result)
+      end
+      result
+        .sort_by { |_, count| count }
+        .reject { |_, count| count == 0 }
+        .map { |names, count| "#{names}: #{count}" }
+    end
+
+    def method_name(ll, result)
+      @dev_pairs.each do |d1, d2|
+        if ll.authored_by?(d1, d2)
+          result[names_key(d1, d2)] += 1
+          return result
+        elsif is_solo_by?(@devs, d1, ll)
+          result[d1.display_name] += 1
+          return result
+        elsif is_solo_by?(@devs, d2, ll)
+          result[d2.display_name] += 1
+          return result
+        end
+      end
+      result
+    end
+
+    def is_solo_by?(devs, person, log_line)
+      no_other_devs_in_commit = (devs - [person]).none? { |dx| log_line.authored_by?(dx) }
+      log_line.authored_by?(person) && no_other_devs_in_commit
+    end
+
+    def names_key(k, v)
+      [k, v].sort_by(&:display_name).map(&:to_s).join(', ')
+    end
+
+    def b(log_line, person1)
+      log_line.authored_by?(person1) && (people - [person1]).none? { |single_person| log_line.authored_by?(single_person) }
+    end
+
+    def a(log_line, person1, person2)
+      log_line.authored_by?(person1, person2)
+    end
+
+    def commits_for_pair(person1, person2)
+      @log_lines.commits_for_pair person1, person2
+    end
+
+    def commits_not_by_known_person
+      @log_lines.commits_not_by_known_person @devs
+    end
+
+    def most_recent_commit_date(person1, person2)
+      recent_commit = commits_for_pair(person1, person2).sort_by(&:date).first
+      recent_commit ? recent_commit.date : nil
+    end
+
+    def all_most_recent_commits
+      @dev_pairs.map do |person1, person2|
+        DateCombo.new(most_recent_commit_date(person1, person2), person1, person2)
+      end.sort.reverse.map &:to_s
+    end
+
+    def recommended_pairings
+      should_pair = unpaired_in_range
+      should_pair.empty? ? [least_recent_pair] : should_pair
+    end
+
+    def least_recent_pair
+      devs.select do |person|
+        person.names.any? { |name| @log_lines.last.line.match(name) }
+      end.map(&:display_name).join(', ')
+    end
+
+    def unpaired_in_range
+      @dev_pairs.select do |person1, person2|
+        most_recent_commit_date(person1, person2).nil?
+      end.map do |person1, person2|
+        "#{person1}, #{person2}"
+      end
+    end
+  end
+end