codespicuous 0.0.1

data/lib/codespicuous/svn_log_parser.rb

@@ -0,0 +1,100 @@
+
+require 'rexml/document'
+
+class SVNLogParser
+
+  def initialize
+    @commits = Commits.new
+  end
+
+  def xml_to_parse(xml_string)
+    @xml_to_parse = xml_string
+  end
+
+  def parse(xml_to_parse = nil)
+    @xml_to_parse = xml_to_parse if xml_to_parse
+
+    xml = REXML::Document.new(@xml_to_parse)
+    validate_xml(xml)
+
+    xml.elements.each( "*/logentry" ) do |logentry|
+      commit = create_commit_from_log_entry(logentry)
+      @commits.add(commit)
+    end
+    self
+  end
+
+  def create_commit_from_log_entry(logentry)
+    commit = Commit.new
+    commit.revision = logentry.attributes["revision"]
+    commit.author = logentry.elements["author"].text
+    commit.message = logentry.elements["msg"].text
+    commit.date = DateTime.parse(logentry.elements["date"].text)
+    commit.changes = create_commit_changes_from_log_entry(logentry)
+    commit
+  end
+
+  def extract_change_type(path)
+    return :modified if path.attributes["action"] == "M"
+    return :added if path.attributes["action"] == "A"
+    return :deleted if path.attributes["action"] == "D"
+    return :renamed if path.attributes["action"] == "R"
+  end
+
+  def extract_kind(path)
+    return :file if path.attributes["kind"] == "file"
+    return :dir if path.attributes["kind"] == "dir"
+  end
+
+  def create_commit_changes_from_log_entry(logentry)
+    changes = []
+    logentry.elements.each("*/path") { |path|
+      change = Change.new
+      change.type = extract_change_type(path)
+      change.kind = extract_kind(path)
+      change.property_changed if  path.attributes["prop-mods"] == "true"
+      change.copyfrom = path.attributes["copyfrom-path"]
+      change.copyrev = path.attributes["copyfrom-rev"]
+      change.file = path.text
+      changes << change
+    }
+    changes
+  end
+
+  def validate_xml(xml)
+    non_logentries = xml.elements["log"].elements.collect { |e| e.name unless e.name == "logentry" }.compact
+    non_logentries.each { |e| raise("Unexpected log entry: " + e) }
+
+    xml.elements.each( "*/logentry" ) do |logentry|
+      validate_log_entry(logentry)
+    end
+  end
+
+  def validate_log_entry logentry
+    invalid_attributes = logentry.attributes.collect { |a| a[0] unless a[0] == "revision" }.compact
+    invalid_attributes.each { |a| raise ("Unexpected attributes log entry: " + a) }
+
+    invalid_elements = logentry.elements.collect { |e| e.name unless ["author", "date", "paths", "msg"].include? e.name }.compact
+    invalid_elements.each { |e| raise ("Unexpected element in log entry: " + e) }
+
+    logentry.elements.each("*/path") { |path|
+      validate_path path
+    }
+  end
+
+  def validate_path path
+    path.elements.each { |e| raise ("Unexpected element in path: " + e.name) }
+
+    invalid_attributes = path.attributes.collect { |a| a[0] unless ["action", "prop-mods", "text-mods", "kind", "copyfrom-path", "copyfrom-rev"].include? a[0] }.compact
+    invalid_attributes.each { |a| raise ("Unexpected attributes in path: " + a) }
+
+    raise("Unexpected value to attribute action in path: " + path.attributes["action"]) unless ["R", "M", "A", "D"].include?(path.attributes["action"])
+    raise("Unexpected value to attribute kind in path: " + path.attributes["kind"]) unless ["file", "dir"].include?(path.attributes["kind"])
+
+    puts "Unexpected value to attribute text-mods in path: " + path.attributes["text-mods"] if path.attributes["text-mods"] == "false" and not ["D", "R"].include?(path.attributes["action"]) and path.attributes["kind"] != "dir"
+  end
+
+  def commits
+    @commits
+  end
+end

data/lib/codespicuous/teams.rb

@@ -0,0 +1,99 @@
+
+class Team
+
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+    @members = {}
+  end
+
+  def add_member(member)
+    @members[member.username] = member
+    member.team = self
+  end
+
+  def members
+    @members.values
+  end
+
+  def each_member
+    @members.values.each { |member|
+      yield member
+    }
+  end
+
+  def amount_of_members
+    @members.size
+  end
+
+  def member_usernames
+    @members.keys
+  end
+
+  def <=> other
+    @name <=> other.name
+  end
+
+  def ==(team)
+    name == team.name && members == team.members
+  end
+end
+
+class Teams
+
+  attr_reader :teams
+
+  def initialize
+    @teams = {}
+  end
+
+  def find_by_name(name)
+    @teams[name]
+  end
+
+  def team_names
+    @teams.keys
+  end
+
+  def each
+    @teams.values.sort.each { |team|
+      yield team
+    }
+  end
+
+  def map(&block)
+    @teams.values.map(&block)
+  end
+
+  def each_member
+    @teams.values.each { |team|
+      team.each_member { |member|
+        yield team, member
+      }
+    }
+  end
+
+  def team(name)
+    @teams[name] ||= Team.new(name)
+  end
+
+  def add(team)
+    @teams[team.name] = team
+  end
+
+  def amount
+    @teams.size
+  end
+
+  def member_usernames(team_name = nil)
+    @teams.values.collect { |team|
+      team.member_usernames if team.name == team_name || team_name == nil
+    }.compact.flatten
+  end
+
+  def ==(teams)
+    @teams == teams.teams
+  end
+end
+

data/lib/codespicuous/version.rb

@@ -0,0 +1,4 @@
+
+module Codespicuous
+  VERSION = "0.0.1"
+end

data/spec/codespicuous_spec.rb

@@ -0,0 +1,81 @@
+
+describe "Codespicuous command line" do
+
+  subject {Codespicuous.new}
+
+  it "prints an error message when no config it present" do
+    expect(subject).to receive(:puts).with("Stage 1: Configuring")
+    expect($stdout).to receive(:puts).with("** Error: No repositories configured in \"codespicuous.yaml\"")
+
+    expect(subject.run([])).to eq false
+  end
+
+  it "creates a configurator, collect data, and lists the repositories the people committed to" do
+    subject.config.list_repositories = true
+
+    expect(subject).to receive(:puts).with("Stage 1: Configuring")
+    expect(subject).to receive(:configure).and_return(true)
+    expect(subject).to receive(:puts).with("Stage 2: Collecting input data")
+    expect(subject).to receive(:collect)
+    expect(subject).to receive(:puts).with("Stage 3: Listing repositories committed to")
+    expect(subject).to receive(:list_committed_repositories)
+
+    expect(subject.run([])).to eq true
+  end
+
+  it "creates a configurator, collect data, and generate output" do
+    expect(subject).to receive(:puts).with("Stage 1: Configuring")
+    expect(subject).to receive(:configure).and_return(true)
+    expect(subject).to receive(:puts).with("Stage 2: Collecting input data")
+    expect(subject).to receive(:collect)
+    expect(subject).to receive(:puts).with("Stage 3: Generating output")
+    expect(subject).to receive(:generate_output)
+
+    expect(subject.run([])).to eq true
+  end
+
+  it "configures the config data" do
+    configurator = CodespicuousConfigurator.new(subject.config)
+    repositories = Repositories.new
+    committers = Committers.new
+    teams = Teams.new
+
+    expect(CodespicuousConfigurator).to receive(:new).and_return(configurator)
+    expect(configurator).to receive(:configure).with(["argv"]).and_return(true)
+
+    expect(configurator).to receive(:repositories).and_return(repositories)
+    expect(configurator).to receive(:committers).and_return(committers)
+    expect(configurator).to receive(:teams).and_return(teams)
+
+    subject.configure(["argv"])
+    expect(subject.committers).to be committers
+    expect(subject.repositories).to be repositories
+    expect(subject.teams).to be teams
+  end
+
+  it "collects the input data" do
+    collector = SVNDataCollector.new(subject.config)
+    commit_history = CommitHistory.new
+    expect(SVNDataCollector).to receive(:new).and_return(collector)
+    expect(collector).to receive(:collect_commit_history).with(subject.repositories).and_return(commit_history)
+
+    subject.collect
+
+    expect(subject.commit_history).to eq commit_history
+  end
+
+  it "generates output" do
+    generator = MetricsGenerator.new
+    expect(MetricsGenerator).to receive(:new).and_return(generator)
+    expect(generator).to receive(:generate).with(subject.commit_history)
+    subject.generate_output
+  end
+
+  it "lists the repositories" do
+    lister = RepositoryLister.new
+    expect(RepositoryLister).to receive(:new).and_return(lister)
+    expect(lister).to receive(:list).with(subject.commit_history)
+    subject.list_committed_repositories
+  end
+end
+

data/spec/codespicuousconfigurator_spec.rb

@@ -0,0 +1,202 @@
+
+describe "CodepicuousConfigurator reads all the config files and provides the data needed for running Codespicuous" do
+
+  subject { CodespicuousConfigurator.new(CodespicuousConfig.new) }
+
+  it "Should process the yaml file" do
+    expect(subject).to receive(:parse_command_line_arguments).with(["argv"])
+    expect(subject).to receive(:configure_from_yaml)
+    expect(subject).to receive(:postprocess_yaml_configuration)
+    expect(subject).to receive(:find_alternative_configuration_files)
+    expect(subject).to receive(:validate_configuration)
+    subject.configure(["argv"])
+  end
+
+  it "should be able to handle the -r command line option" do
+    subject.parse_command_line_arguments(["-r"])
+    expect(subject.config.list_repositories).to be true
+  end
+
+  it "Should be able to handle the -i command line option for input directory " do
+    subject.parse_command_line_arguments(["-i", "blah"])
+    expect(subject.config.input_path).to eq Pathname.new("blah")
+  end
+
+  it "Should be able to handle the -o command line option for output directory " do
+    subject.parse_command_line_arguments(["-o", "blah"])
+    expect(subject.config.output_path).to eq Pathname.new("blah")
+  end
+
+  it "Should post process the YAML file" do
+    yaml_content = {}
+
+    expect(subject).to receive(:postprocess_yaml_configuration_repositories).with(yaml_content)
+    expect(subject).to receive(:postprocess_yaml_configuration_committers).with(yaml_content)
+
+    subject.postprocess_yaml_configuration(yaml_content)
+  end
+
+  it "Should find alternative config files" do
+    expect(subject).to receive(:find_alternative_configuration_files_for_repositories)
+    expect(subject).to receive(:find_alternative_configuration_files_for_committers)
+
+    subject.find_alternative_configuration_files
+  end
+
+  context "Read the YAML file" do
+
+    it "reads the codespicuous configuration from YAML file when the file exists" do
+      expect(File).to receive(:exist?).with("codespicuous.yaml").and_return(true)
+      expect(File).to receive(:read).with("codespicuous.yaml").and_return("offline: true")
+      expect(subject).to receive(:puts).with('** Configuring options with "codespicuous.yaml"')
+
+      subject.configure_from_yaml
+      expect(subject.config.offline).to eq true
+    end
+
+    it "Ignores the missing options file and tries to use defaults" do
+      expect(File).to receive(:exist?).with("codespicuous.yaml").and_return(false)
+
+      subject.configure_from_yaml
+
+      expect(subject.config.offline).to eq false
+    end
+  end
+
+  context "Parsing the repositories" do
+
+    it "Processes the repositories out of the options with all selected" do
+
+      yaml_content = {"repositories" => { "name" => "url"}}
+
+      subject.postprocess_yaml_configuration_repositories(yaml_content)
+
+      repositories = Repositories.new
+      repositories.add(Repository.new("name", "url"))
+
+      expect(subject.repositories).to eq repositories
+      expect(subject.repositories_to_check).to eq repositories
+    end
+
+    it "Processes the repositories out of the options, with only the selected one" do
+
+      yaml_content = {"repositories" => { "name" => "url", "name2" => "url2"},
+                      "repositories_to_check" => ["name2"]}
+
+      subject.postprocess_yaml_configuration_repositories(yaml_content)
+
+      repositories = Repositories.new
+      repositories.add(Repository.new("name", "url"))
+      repositories.add(Repository.new("name2", "url2"))
+
+      checked_repositories = Repositories.new
+      checked_repositories.add(Repository.new("name2", "url2"))
+
+      expect(subject.repositories).to eq repositories
+      expect(subject.repositories_to_check).to eq checked_repositories
+    end
+
+    it "will not bother checking the CSV file when it found repositories already" do
+      repositories = Repositories.new
+      repositories.add(Repository.new("name", "url"))
+      expect(subject).to receive(:repositories).and_return(repositories)
+      expect(File).not_to receive(:exist?)
+
+      subject.find_alternative_configuration_files_for_repositories
+    end
+
+    it "will check whether there is a CSV file and continue if not found" do
+      expect(File).to receive(:exist?).with("repositories.csv").and_return(false)
+
+      subject.find_alternative_configuration_files_for_repositories
+
+      expect(subject.repositories).to eq Repositories.new
+    end
+
+    it "will read the CSV file when it exists" do
+      expect(File).to receive(:exist?).with("repositories.csv").and_return(true)
+      expect(File).to receive(:read).with("repositories.csv").and_return("name,url\nrepos,https://repos.com")
+      expect(subject).to receive(:puts).with('** Configuring repositories with "repositories.csv"')
+
+      subject.find_alternative_configuration_files_for_repositories
+
+      repositories = Repositories.new
+      repositories.add(Repository.new("repos", "https://repos.com"))
+
+      expect(subject.repositories).to eq repositories
+    end
+  end
+
+  context "Parsing the teams and committers" do
+
+    before (:each) do
+      @team_wine = Team.new("Wine")
+      @committer_bas = Committer.create_committer("basvodde", "Bas", "Vodde", "basv@wow.com", @team_wine)
+    end
+
+    it "can have no committers and teams. Just empty then" do
+      subject.postprocess_yaml_configuration_committers({})
+
+      expect(subject.committers).to eq Committers.new
+      expect(subject.teams).to eq Teams.new
+    end
+
+    it "can get the team info from the yaml file" do
+
+      yaml_content = {"teams" =>
+                        {"Wine" => [{
+                          "First Name" => "Bas",
+                          "Last Name" => "Vodde",
+                          "Email" => "basv@wow.com",
+                          "Login" => "basvodde" } ]
+                          } }
+
+      subject.postprocess_yaml_configuration_committers(yaml_content)
+
+      committers = Committers.new
+      @team_wine.add_member(@committer_bas)
+      committers.add(@committer_bas)
+
+      teams = Teams.new
+      teams.add(@team_wine)
+
+      expect(subject.committers).to eq committers
+      expect(subject.teams).to eq teams
+
+    end
+
+    it "will not bother checking the CSV file when it found committers already" do
+      committers = Committers.new
+      committers.add(@committer_bas)
+      expect(subject).to receive(:committers).and_return(committers)
+      expect(File).not_to receive(:exist?)
+
+      subject.find_alternative_configuration_files_for_committers
+    end
+
+    it "will check whether there is a CSV file and continue if not found" do
+      expect(File).to receive(:exist?).with("committers.csv").and_return(false)
+
+      subject.find_alternative_configuration_files_for_committers
+
+      expect(subject.committers).to eq Committers.new
+    end
+
+    it "will read the CSV file when it exists" do
+      expect(File).to receive(:exist?).with("committers.csv").and_return(true)
+      expect(File).to receive(:read).with("committers.csv").and_return("#,First Name,Last Name,Email,Login,Team,Specialization,Manager,day1,day2,day3,Comments,Present,Questionaire send,Answered,Pretest,Dietary,Commits,Blamed lines,Average LOC/Commit
+#1,Bas,Vodde,basv@wow.com,basvodde,Wine")
+      expect(subject).to receive(:puts).with('** Configuring committers with "committers.csv"')
+
+      subject.find_alternative_configuration_files_for_committers
+
+      committers = Committers.new
+      committers.add(@committer_bas)
+
+      expect(subject.committers).to eq committers
+    end
+
+  end
+
+end
+