trollolo 0.0.3 → 0.0.4

data/lib/settings.rb

@@ -17,8 +17,9 @@
 
 class Settings
 
-  attr_accessor :verbose, :raw
-  attr_accessor :developer_public_key, :member_token
+  attr_accessor :developer_public_key, :member_token, :verbose, :raw,
+                :not_done_columns, :todo_column, :done_column_name_regex,
+                :todo_column_name_regex
 
   def initialize config_file_path
     @config_file_path = config_file_path
@@ -26,8 +27,12 @@ class Settings
       @config = YAML.load_file(config_file_path)
 
       if @config
-        @developer_public_key = @config["developer_public_key"]
-        @member_token = @config["member_token"]
+        @developer_public_key   = @config["developer_public_key"]
+        @member_token           = @config["member_token"]
+        @not_done_columns       = @config["not_done_columns"].freeze || ["Sprint Backlog", "Doing"]
+        @todo_column            = @config["todo_column"].freeze
+        @done_column_name_regex = @config["done_column_name_regex"].freeze || /\ADone Sprint (\d+)\Z/
+        @todo_column_name_regex = @config["todo_column_name_regex"].freeze || /\ATo Do\Z/
       else
         raise "Couldn't read config data from '#{config_file_path}'"
       end

data/lib/trello_wrapper.rb

@@ -0,0 +1,62 @@
+#  Copyright (c) 2013-2014 SUSE LLC
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of version 3 of the GNU General Public License as
+#  published by the Free Software Foundation.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, contact SUSE LLC.
+#
+#  To contact SUSE about this file by physical or electronic mail,
+#  you may find current contact information at www.suse.com
+require 'trello'
+
+class TrelloWrapper
+
+  attr_accessor :board
+
+  def initialize(settings)
+    @settings = settings
+    init_trello
+  end
+
+  def client
+    Trello::Client.new(
+      developer_public_key: @settings.developer_public_key,
+      member_token: @settings.member_token
+    )
+  end
+
+  def board(board_id)
+    return @board if @board
+
+    @board = ScrumBoard.new(retrieve_board_data(board_id), @settings)
+  end
+
+  def retrieve_board_data(board_id)
+    JSON.parse(client.get("/boards/#{board_id}?lists=open&cards=open&card_checklists=all"))
+  end
+
+  def backup(board_id)
+    client.get("/boards/#{board_id}?lists=open&cards=open&card_checklists=all")
+  end
+
+  def organization(org_id)
+    Trello::Organization.find(org_id)
+  end
+
+  private
+
+  def init_trello
+    Trello.configure do |config|
+      config.developer_public_key = @settings.developer_public_key
+      config.member_token         = @settings.member_token
+    end
+  end
+
+end

data/lib/trollolo.rb

@@ -15,20 +15,23 @@
 #  To contact SUSE about this file by physical or electronic mail,
 #  you may find current contact information at www.suse.com
 
-require "thor"
-require "net/http"
-require "net/https"
-require "json"
-require "yaml"
-require "erb"
+require 'thor'
+require 'json'
+require 'yaml'
+require 'erb'
 
+require_relative 'array'
 require_relative 'version'
 require_relative 'cli'
 require_relative 'settings'
-require_relative 'trello'
+require_relative 'column'
 require_relative 'card'
+require_relative 'scrum_board'
+require_relative 'result'
+require_relative 'trello_wrapper'
 require_relative 'burndown_chart'
 require_relative 'burndown_data'
+require_relative 'backup'
 
 class TrolloloError < StandardError
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module Trollolo
 
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 
 end

data/scripts/.gitignore

@@ -0,0 +1 @@
+*.pyc

data/scripts/burndowndata.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+import yaml
+
+
+class BurndownData:
+  "Store burndown data parsed from YAML file"
+
+  def __init__(self, args):
+    self.args = args
+    burndown = self.readYAML(self.args.sprint)
+    self.getSprintData(burndown)
+    self.calculateMaxStoryPoints()
+    self.setBonusTasksDayOne(burndown)
+    self.setExtraDays()
+    self.calculateYRange(self.max_story_points, self.bonus_tasks_done, self.bonus_story_points_done)
+    self.setScaleFactor(self.total_tasks[0], self.max_story_points)
+
+  def readYAML(self, sprint_number):
+    with open('burndown-data-' + sprint_number + '.yaml', 'r') as f:
+      burndown = yaml.load(f)
+    return burndown
+
+  def getSprintData(self, burndown):
+    self.sprint_number = burndown["meta"]["sprint"]
+    self.weekend_lines = burndown["meta"]["weekend_lines"]
+    self.total_days = burndown["meta"]["total_days"]
+    self.extra_day = 0
+    self.current_day = 1
+    self.days = []
+    self.tasks_extra_days = []
+    self.story_points_extra_days = []
+    self.open_story_points = []
+    self.total_story_points = []
+    self.bonus_story_points_done = []
+    self.open_tasks = []
+    self.total_tasks = []
+    self.bonus_tasks_done = []
+    self.x_fast_lane = []
+    self.y_fast_lane = []
+    self.total_fast_lane = []
+    self.max_story_points = 0
+
+    for day in burndown["days"]:
+      self.days.append(self.current_day)
+      self.open_story_points.append(day["story_points"]["open"])
+      self.total_story_points.append(day["story_points"]["total"])
+      self.open_tasks.append(day["tasks"]["open"])
+      self.total_tasks.append(day["tasks"]["total"])
+
+      if "tasks_extra" in day:
+        self.tasks_extra_days.append(self.current_day)
+        tasks = -day["tasks_extra"]["done"]
+        self.bonus_tasks_done.append(tasks)
+
+      if "story_points_extra" in day:
+        self.story_points_extra_days.append(self.current_day)
+        points = -day["story_points_extra"]["done"]
+        self.bonus_story_points_done.append(points)
+
+      if day.has_key("fast_lane"):
+        self.x_fast_lane.append(self.current_day)
+        self.y_fast_lane.append(day["fast_lane"]["open"])
+        self.total_fast_lane.append(day["fast_lane"]["total"])
+
+      self.current_day += 1
+    return
+
+  def calculateMaxStoryPoints(self):
+    for sp in self.total_story_points:
+      self.max_story_points = max(self.max_story_points, sp)
+    return
+
+  def setBonusTasksDayOne(self, burndown):
+    if burndown["days"][0].has_key("tasks_extra"):
+      self.bonus_tasks_day_one = burndown["days"][0]["tasks_extra"]["done"]
+    else:
+      self.bonus_tasks_day_one = 0
+    return
+
+  def setExtraDays(self):
+    if len(self.story_points_extra_days) > 0:
+      self.story_points_extra_days = [self.story_points_extra_days[0] - 1] + self.story_points_extra_days
+      self.bonus_story_points_done = [0] + self.bonus_story_points_done
+    if len(self.tasks_extra_days) > 0:
+      if not self.args.no_tasks and not self.bonus_tasks_day_one:
+        self.tasks_extra_days = [self.tasks_extra_days[0] - 1] + self.tasks_extra_days
+        self.bonus_tasks_done = [0] + self.bonus_tasks_done
+      self.extra_day = 1
+    return
+
+  def calculateYRange(self, max_story_points, bonus_tasks_done, bonus_story_points_done):
+    self.ymax = max_story_points + 3
+
+    if len(bonus_tasks_done) > 0:
+      ymin_bonus_tasks = min(bonus_tasks_done) -3
+    else:
+      ymin_bonus_tasks = 0
+
+    ymin_bonus_story_points = 0
+
+    if len(bonus_story_points_done) > 0:
+      ymin_bonus_story_points = min(bonus_story_points_done) -3
+
+    if ymin_bonus_tasks == 0 and ymin_bonus_story_points == 0:
+      self.ymin = -3
+    else:
+      self.ymin = min(ymin_bonus_tasks, ymin_bonus_story_points)
+    return
+
+  def setScaleFactor(self, total_tasks, max_story_points):
+    self.scalefactor = float(total_tasks) / float(max_story_points)
+    return
+

data/scripts/create_burndown.py

@@ -1,149 +1,114 @@
-#!/usr/bin/python
+#!/usr/bin/env python
+import matplotlib
+import imp
+try:
+  imp.find_module('TkAgg')
+  mac_backend_available = True
+except ImportError:
+  mac_backend_available = False
+
+if mac_backend_available:
+  matplotlib.use('TkAgg')
+
 import matplotlib.pyplot as plt
-import numpy as np
-import sys
-import yaml
-
-if len(sys.argv) != 2:
-  print "Usage: machinery-burndown.py <sprint-number>"
-  sys.exit(1)
-
-sprint = sys.argv[1]
-
-with open('burndown-data-' + sprint + '.yaml', 'r') as f:
-  burndown = yaml.load(f)
-
-meta = burndown["meta"]
-
-total_days = meta["total_days"]
-
-current_day = 1
-x_days = []
-y_open_story_points = []
-y_open_tasks = []
-total_tasks = []
-total_story_points = []
-x_days_extra = []
-x_day_extra_start = []
-y_story_points_done_extra = [0]
-y_tasks_done_extra = [0]
-
-for day in burndown["days"]:
-  x_days.append(current_day)
-  y_open_story_points.append(day["story_points"]["open"])
-  y_open_tasks.append(day["tasks"]["open"])
-  total_tasks.append(day["tasks"]["total"])
-  total_story_points.append(day["story_points"]["total"])
-
-  if "story_points_extra" in day or "tasks_extra" in day:
-    x_days_extra.append(current_day)
-    tasks = 0
-    if day.has_key("tasks_extra"):
-      tasks = -day["tasks_extra"]["done"]
-    y_tasks_done_extra.append(tasks)
-    points = 0
-    if day.has_key("story_points_extra"):
-      points = -day["story_points_extra"]["done"]
-    y_story_points_done_extra.append(points)
-
-  current_day += 1
-
-# Add a day at the beginning of the extra days, so the curve starts at zero
-if x_days_extra:
-  x_days_extra = [x_days_extra[0] - 1] + x_days_extra
-
-scalefactor = float(total_tasks[0]) / float(y_open_story_points[0])
-
-# Calculate minimum and maximum 'y' values for the axis
-ymin_t_extra = 0
-ymin_s_extra = 0
-ymax = y_open_story_points[0] + 3
-
-if len(y_tasks_done_extra) > 0:
-  ymin_t_extra = y_tasks_done_extra[len(y_tasks_done_extra) -1] -3
-if len(y_story_points_done_extra) > 0:
-  ymin_s_extra = y_story_points_done_extra[len(y_story_points_done_extra) -1] -3
-if ymin_t_extra < ymin_s_extra:
-  ymin = ymin_t_extra
-else:
-  ymin = ymin_s_extra
-if ymin_t_extra == 0 and ymin_s_extra == 0:
-  ymin = -3
-
-# Plot in xkcd style
-plt.xkcd()
-
-plt.figure(1, figsize=(11, 6))
-
-# Title of the burndown chart
-plt.suptitle('Sprint ' + sprint, fontsize='large')
-
-plt.xlabel('Days')
-plt.axis([0, total_days + 1, ymin, ymax])
-plt.plot([1, total_days] , [y_open_story_points[0], 0], color='grey')
-plt.plot([0, total_days + 1], [0, 0], color='blue', linestyle=':')
-
-# Weekend lines
-for weekend_line in meta["weekend_lines"]:
-  plt.plot([weekend_line, weekend_line], [ymin+1, ymax-1], color='grey', linestyle=':')
-
-# Story points
-plt.ylabel('Story Points', color='black')
-plt.plot(x_days, y_open_story_points, 'ko-', linewidth=2)
-if x_days_extra:
-  plt.plot(x_days_extra, y_story_points_done_extra, 'ko-', linewidth=2)
-
-# Tasks
-plt.twinx()
-plt.ylabel('Tasks', color='green')
-plt.tick_params(axis='y', colors='green')
-plt.axis([0, total_days + 1, ymin*scalefactor, ymax * scalefactor])
-plt.plot(x_days, y_open_tasks, 'go-', linewidth=2)
-if x_days_extra:
-  plt.plot(x_days_extra, y_tasks_done_extra, 'go-', linewidth=2)
-
-# Calculation of new tasks
-if len(total_tasks) > 1:
-  new_tasks = [0]
-  for i in range(1, len(total_tasks)):
-    new_tasks.append(total_tasks[i] - total_tasks[i - 1])
-  effective_new_tasks_days = []
-  effective_new_tasks = []
-  for i in range(len(new_tasks)):
-    if new_tasks[i] != 0:
-      effective_new_tasks_days.append(i - 0.25 + 1)
-      effective_new_tasks.append(new_tasks[i])
-  if len(effective_new_tasks) > 0:
-    plt.bar(effective_new_tasks_days, effective_new_tasks, .2, color='green')
-
-# Calculation of new story points
-if len(total_story_points) > 1:
-  new_story_points = [0]
-  for i in range(1, len(total_story_points)):
-    new_story_points.append(total_story_points[i] - total_story_points[i - 1])
-  effective_new_story_points_days = []
-  effective_new_story_points = []
-  for i in range(len(new_story_points)):
-    if new_story_points[i] != 0:
-      effective_new_story_points_days.append(i + 0.05 + 1)
-      effective_new_story_points.append(new_story_points[i])
-  if len(effective_new_story_points) > 0:
-    plt.bar(effective_new_story_points_days, effective_new_story_points, .2, color='black')
-
-# Draw arrow showing already done tasks at begin of sprint
-tasks_done = burndown["days"][0]["tasks"]["total"] - burndown["days"][0]["tasks"]["open"]
-
-if tasks_done > 5:
-  plt.annotate("", 
-	       xy=(x_days[0], scalefactor * y_open_story_points[0] - 0.5 ), xycoords='data',
-	       xytext=(x_days[0], y_open_tasks[0] + 0.5), textcoords='data',
-	       arrowprops=dict(arrowstyle="<|-|>", connectionstyle="arc3", color='green')
-	      )
-
-  plt.text(0.7, y_open_story_points[0], str(tasks_done) + " tasks done",
-	   rotation='vertical', verticalalignment='center', color='green'
-	  )
+import argparse
+import os
+
+import burndowndata
+import plot
+import graph
+
+
+def parseCommandLine():
+  epilog = "Look at https://github.com/openSUSE/trollolo for details"
+  description = "Generates Scrum Burndown Chart from YAML file"
+
+  parser = argparse.ArgumentParser(epilog=epilog, description=description)
+  parser.add_argument('sprint', metavar='NUM', help='Sprint Number')
+  parser.add_argument('--output', help='Location of data to process')
+  parser.add_argument('--no-tasks', action='store_true', help='Disable Tasks line in the chart', default=False)
+  parser.add_argument('--with-fast-lane', action='store_true', help='Draw line for Fast Lane cards', default=False)
+  parser.add_argument('--verbose', action='store_true', help='Verbose Output', default=False)
+  parser.add_argument('--no-head', action='store_true', help='Run in headless mode', default=False)
+  args = parser.parse_args()
+
+  if args.output:
+    os.chdir(args.output)
+
+  if args.verbose:
+    print args
+
+  return args
+
+
+
+### MAIN ###
+
+# parseCommandLine() needs to be called at the beginning to retrieve the
+# command line parameters or provide help on these. It returns a dict
+# containing the state of all parameters. Currently the following
+# parameters are available:
+#
+# Mandatory parameters:
+# NUM                The sprint number for which the burndown chart should be generated
+#
+# Optional parameters:
+# --file             Specify the location of the YAML file containing the sprint data,
+#                    if not provided, the YAML file is expected to be in the current
+#                    working directory
+#
+# --no-tasks         Disable drawing the tasks graph in the chart
+#
+# --with-fast-lane   Enable drawing the graph for fast lane cards in the chart
+#
+# --no-head          Disable showing the graph, to be used for automation
+#
+# --verbose          Verbose output
+#
+args = parseCommandLine()
+
+# Create burndown data object
+data = burndowndata.BurndownData(args)
+
+# Configure plot parameters
+plot = plot.Plot(data)
+
+title = "Sprint" + str(data.sprint_number)
+title_fontsize = 'large'
+plot.setTitle(title, title_fontsize)
+plot.setXAxisLabel("Days")
+
+plot.drawDiagonal("grey")
+plot.drawWaterLine("blue", ":")
+plot.drawWeekendLines("grey", ":")
+
+# Plot all graphs
+graph_story_points = graph.Graph(plot.storyPoints())
+
+y_label = "Story Points"
+color = "black"
+marker = "o"
+linestyle = "solid"
+linewidth = 2
+
+graph_story_points.draw(y_label, color, marker, linestyle, linewidth, plot)
+
+if not args.no_tasks:
+  graph_tasks = graph.Graph(plot.tasks())
+
+  y_label = "Tasks"
+  color = "green"
+
+  graph_tasks.draw(y_label, color, marker, linestyle, linewidth, plot)
+
+if args.with_fast_lane:
+  graph_fast_lane = graph.Graph(plot.fastLane())
+
+  y_label = "Fast Lane"
+  color = "red"
+
+  graph_fast_lane.draw(y_label, color, marker, linestyle, linewidth, plot)
 
 # Save the burndown chart
-plt.savefig('burndown-' + sprint + '.png',bbox_inches='tight')
-plt.show()
+plot.saveImage(args)
+