| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var Model; |
| 3 | ||
| 4 | 1 | Model = require('../utils/ractive/model.coffee'); |
| 5 | ||
| 6 | 1 | module.exports = new Model({ |
| 7 | 'name': 'models/config', | |
| 8 | "data": { | |
| 9 | "firebase": "burnchart", | |
| 10 | "provider": "github", | |
| 11 | "fields": { | |
| 12 | "milestone": ["closed_issues", "created_at", "description", "due_on", "number", "open_issues", "title", "updated_at"] | |
| 13 | }, | |
| 14 | "chart": { | |
| 15 | "off_days": [], | |
| 16 | "datetime": /^(\d{4}-\d{2}-\d{2})T(.*)/, | |
| 17 | "size_label": /^size (\d+)$/, | |
| 18 | "location": /^#!((\/[^\/]+){2,3})$/, | |
| 19 | "points": 'ONE_SIZE' | |
| 20 | }, | |
| 21 | "request": { | |
| 22 | "timeout": 5e3 | |
| 23 | } | |
| 24 | } | |
| 25 | }); | |
| 26 | ||
| 27 | }).call(this); | |
| 28 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var Model, config, lscache, semver, sortedIndex, stats, user, _, |
| 3 | __slice = [].slice; | |
| 4 | ||
| 5 | 1 | _ = require('lodash'); |
| 6 | ||
| 7 | 1 | lscache = require('lscache'); |
| 8 | ||
| 9 | 1 | sortedIndex = require('sortedindex-compare'); |
| 10 | ||
| 11 | 1 | semver = require('semver'); |
| 12 | ||
| 13 | 1 | Model = require('../utils/ractive/model.coffee'); |
| 14 | ||
| 15 | 1 | config = require('../models/config.coffee'); |
| 16 | ||
| 17 | 1 | stats = require('../modules/stats.coffee'); |
| 18 | ||
| 19 | 1 | user = require('./user.coffee'); |
| 20 | ||
| 21 | 1 | module.exports = new Model({ |
| 22 | 'name': 'models/projects', | |
| 23 | 'data': { | |
| 24 | 'sortBy': 'priority', | |
| 25 | 'sortFns': ['progress', 'priority', 'name'] | |
| 26 | }, | |
| 27 | comparator: function() { | |
| 28 | 0 | var deIdx, defaults, list, sortBy, _ref; |
| 29 | 0 | _ref = this.data, list = _ref.list, sortBy = _ref.sortBy; |
| 30 | 0 | deIdx = (function(_this) { |
| 31 | 0 | return function(fn) { |
| 32 | 0 | return function() { |
| 33 | 0 | var i, j, rest, _arg; |
| 34 | 0 | _arg = arguments[0], rest = 2 <= arguments.length ? __slice.call(arguments, 1) : []; |
| 35 | 0 | i = _arg[0], j = _arg[1]; |
| 36 | 0 | return fn.apply(_this, [[list[i], list[i].milestones[j]]].concat(rest)); |
| 37 | }; | |
| 38 | }; | |
| 39 | })(this); | |
| 40 | 0 | defaults = function(arr, hash) { |
| 41 | 0 | var i, item, k, keys, p, ref, v, _i, _len, _results; |
| 42 | 0 | _results = []; |
| 43 | 0 | for (_i = 0, _len = arr.length; _i < _len; _i++) { |
| 44 | 0 | item = arr[_i]; |
| 45 | 0 | _results.push((function() { |
| 46 | 0 | var _results1; |
| 47 | 0 | _results1 = []; |
| 48 | 0 | for (k in hash) { |
| 49 | 0 | v = hash[k]; |
| 50 | 0 | ref = item; |
| 51 | 0 | _results1.push((function() { |
| 52 | 0 | var _j, _len1, _ref1, _results2; |
| 53 | 0 | _ref1 = keys = k.split('.'); |
| 54 | 0 | _results2 = []; |
| 55 | 0 | for (i = _j = 0, _len1 = _ref1.length; _j < _len1; i = ++_j) { |
| 56 | 0 | p = _ref1[i]; |
| 57 | 0 | if (i === keys.length - 1) { |
| 58 | 0 | _results2.push(ref[p] != null ? ref[p] : ref[p] = v); |
| 59 | } else { | |
| 60 | 0 | _results2.push(ref = ref[p] != null ? ref[p] : ref[p] = {}); |
| 61 | } | |
| 62 | } | |
| 63 | 0 | return _results2; |
| 64 | })()); | |
| 65 | } | |
| 66 | 0 | return _results1; |
| 67 | })()); | |
| 68 | } | |
| 69 | 0 | return _results; |
| 70 | }; | |
| 71 | 0 | switch (sortBy) { |
| 72 | case 'progress': | |
| 73 | 0 | return deIdx(function(_arg, _arg1) { |
| 74 | 0 | var aM, aP, bM, bP; |
| 75 | 0 | aP = _arg[0], aM = _arg[1]; |
| 76 | 0 | bP = _arg1[0], bM = _arg1[1]; |
| 77 | 0 | defaults([aM, bM], { |
| 78 | 'stats.progress.points': 0 | |
| 79 | }); | |
| 80 | 0 | return aM.stats.progress.points - bM.stats.progress.points; |
| 81 | }); | |
| 82 | case 'priority': | |
| 83 | 0 | return deIdx(function(_arg, _arg1) { |
| 84 | 0 | var $a, $b, aM, aP, bM, bP, _ref1; |
| 85 | 0 | aP = _arg[0], aM = _arg[1]; |
| 86 | 0 | bP = _arg1[0], bM = _arg1[1]; |
| 87 | 0 | defaults([aM, bM], { |
| 88 | 'stats.progress.time': 0, | |
| 89 | 'stats.days': 1e3 | |
| 90 | }); | |
| 91 | 0 | _ref1 = _.map([aM, bM], function(_arg2) { |
| 92 | 0 | var stats; |
| 93 | 0 | stats = _arg2.stats; |
| 94 | 0 | return (stats.progress.points - stats.progress.time) * stats.days; |
| 95 | }), $a = _ref1[0], $b = _ref1[1]; | |
| 96 | 0 | return $b - $a; |
| 97 | }); | |
| 98 | case 'name': | |
| 99 | 0 | return deIdx(function(_arg, _arg1) { |
| 100 | 0 | var aM, aP, bM, bP, name, owner; |
| 101 | 0 | aP = _arg[0], aM = _arg[1]; |
| 102 | 0 | bP = _arg1[0], bM = _arg1[1]; |
| 103 | 0 | if (owner = bP.owner.localeCompare(aP.owner)) { |
| 104 | 0 | return owner; |
| 105 | } | |
| 106 | 0 | if (name = bP.name.localeCompare(aP.name)) { |
| 107 | 0 | return name; |
| 108 | } | |
| 109 | 0 | if (semver.valid(bM.title) && semver.valid(aM.title)) { |
| 110 | 0 | return semver.gt(bM.title, aM.title); |
| 111 | } else { | |
| 112 | 0 | return bM.title.localeCompare(aM.title); |
| 113 | } | |
| 114 | }); | |
| 115 | default: | |
| 116 | 0 | return function() { |
| 117 | 0 | return 0; |
| 118 | }; | |
| 119 | } | |
| 120 | }, | |
| 121 | find: function(project) { | |
| 122 | 0 | return _.find(this.data.list, project); |
| 123 | }, | |
| 124 | exists: function() { | |
| 125 | 0 | return !!this.find.apply(this, arguments); |
| 126 | }, | |
| 127 | add: function(project) { | |
| 128 | 0 | if (!this.exists(project)) { |
| 129 | 0 | return this.push('list', project); |
| 130 | } | |
| 131 | }, | |
| 132 | findIndex: function(_arg) { | |
| 133 | 0 | var name, owner; |
| 134 | 0 | owner = _arg.owner, name = _arg.name; |
| 135 | 0 | return _.findIndex(this.data.list, { |
| 136 | owner: owner, | |
| 137 | name: name | |
| 138 | }); | |
| 139 | }, | |
| 140 | addMilestone: function(project, milestone) { | |
| 141 | 6 | var i, j; |
| 142 | 6 | _.extend(milestone, { |
| 143 | 'stats': stats(milestone) | |
| 144 | }); | |
| 145 | 0 | if ((i = this.findIndex(project)) < 0) { |
| 146 | 0 | throw 500; |
| 147 | } | |
| 148 | 0 | if (project.milestones != null) { |
| 149 | 0 | this.push("list." + i + ".milestones", milestone); |
| 150 | 0 | j = this.data.list[i].milestones.length - 1; |
| 151 | } else { | |
| 152 | 0 | this.set("list." + i + ".milestones", [milestone]); |
| 153 | 0 | j = 0; |
| 154 | } | |
| 155 | 0 | return this.sort([i, j], [project, milestone]); |
| 156 | }, | |
| 157 | saveError: function(project, err) { | |
| 158 | 0 | var idx; |
| 159 | 0 | if ((idx = this.findIndex(project)) > -1) { |
| 160 | 0 | if (project.errors != null) { |
| 161 | 0 | return this.push("list." + idx + ".errors", err); |
| 162 | } else { | |
| 163 | 0 | return this.set("list." + idx + ".errors", [err]); |
| 164 | } | |
| 165 | } else { | |
| 166 | 0 | throw 500; |
| 167 | } | |
| 168 | }, | |
| 169 | demo: function() { | |
| 170 | 0 | return this.set({ |
| 171 | 'list': [ | |
| 172 | { | |
| 173 | 'owner': 'mbostock', | |
| 174 | 'name': 'd3' | |
| 175 | }, { | |
| 176 | 'owner': 'medic', | |
| 177 | 'name': 'medic-webapp' | |
| 178 | }, { | |
| 179 | 'owner': 'ractivejs', | |
| 180 | 'name': 'ractive' | |
| 181 | }, { | |
| 182 | 'owner': 'radekstepan', | |
| 183 | 'name': 'disposable' | |
| 184 | }, { | |
| 185 | 'owner': 'rails', | |
| 186 | 'name': 'rails' | |
| 187 | }, { | |
| 188 | 'owner': 'rails', | |
| 189 | 'name': 'spring' | |
| 190 | } | |
| 191 | ], | |
| 192 | 'index': [] | |
| 193 | }); | |
| 194 | }, | |
| 195 | clear: function() { | |
| 196 | 6 | return this.set({ |
| 197 | 'list': [], | |
| 198 | 'index': [] | |
| 199 | }); | |
| 200 | }, | |
| 201 | sort: function(ref, data) { | |
| 202 | 3 | var i, idx, index, j, m, p, _i, _j, _len, _len1, _ref, _ref1; |
| 203 | 3 | index = this.data.index || []; |
| 204 | 3 | if (ref) { |
| 205 | 0 | idx = sortedIndex(index, data, this.comparator()); |
| 206 | 0 | index.splice(idx, 0, ref); |
| 207 | } else { | |
| 208 | 3 | _ref = this.data.list; |
| 209 | 3 | for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) { |
| 210 | 0 | p = _ref[i]; |
| 211 | 0 | if (p.milestones == null) { |
| 212 | 0 | continue; |
| 213 | } | |
| 214 | 0 | _ref1 = p.milestones; |
| 215 | 0 | for (j = _j = 0, _len1 = _ref1.length; _j < _len1; j = ++_j) { |
| 216 | 0 | m = _ref1[j]; |
| 217 | 0 | idx = sortedIndex(index, [p, m], this.comparator()); |
| 218 | 0 | index.splice(idx, 0, [i, j]); |
| 219 | } | |
| 220 | } | |
| 221 | } | |
| 222 | 3 | return this.set('index', index); |
| 223 | }, | |
| 224 | onconstruct: function() { | |
| 225 | 1 | this.subscribe('!projects/add', this.add, this); |
| 226 | 1 | return this.subscribe('!projects/demo', this.demo, this); |
| 227 | }, | |
| 228 | onrender: function() { | |
| 229 | 1 | this.set('list', lscache.get('projects') || []); |
| 230 | 1 | this.observe('list', function(projects) { |
| 231 | 12 | return lscache.set('projects', _.pluckMany(projects, ['owner', 'name'])); |
| 232 | }, { | |
| 233 | 'init': false | |
| 234 | }); | |
| 235 | 1 | return this.observe('sortBy', function() { |
| 236 | 3 | this.set('index', null); |
| 237 | 3 | return this.sort(); |
| 238 | }, { | |
| 239 | 'init': false | |
| 240 | }); | |
| 241 | } | |
| 242 | }); | |
| 243 | ||
| 244 | }).call(this); | |
| 245 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var Model; |
| 3 | ||
| 4 | 1 | Model = require('../utils/ractive/model.coffee'); |
| 5 | ||
| 6 | 1 | module.exports = new Model({ |
| 7 | 'name': 'models/user' | |
| 8 | }); | |
| 9 | ||
| 10 | }).call(this); | |
| 11 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var config, d3, _, |
| 3 | 0 | __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }; |
| 4 | ||
| 5 | 1 | _ = require('lodash'); |
| 6 | ||
| 7 | 1 | d3 = require('d3'); |
| 8 | ||
| 9 | 1 | config = require('../../models/config.coffee'); |
| 10 | ||
| 11 | 1 | module.exports = { |
| 12 | actual: function(issues, created_at, total) { | |
| 13 | 0 | var head, max, min, range, rest; |
| 14 | 0 | head = [ |
| 15 | { | |
| 16 | 'date': new Date(created_at), | |
| 17 | 'points': total | |
| 18 | } | |
| 19 | ]; | |
| 20 | 0 | min = +Infinity; |
| 21 | 0 | max = -Infinity; |
| 22 | 0 | rest = _.map(issues, function(issue) { |
| 23 | 0 | var closed_at, size; |
| 24 | 0 | size = issue.size, closed_at = issue.closed_at; |
| 25 | 0 | if (size < min) { |
| 26 | 0 | min = size; |
| 27 | } | |
| 28 | 0 | if (size > max) { |
| 29 | 0 | max = size; |
| 30 | } | |
| 31 | 0 | issue.date = new Date(closed_at); |
| 32 | 0 | issue.points = total -= size; |
| 33 | 0 | return issue; |
| 34 | }); | |
| 35 | 0 | range = d3.scale.linear().domain([min, max]).range([5, 8]); |
| 36 | 0 | rest = _.map(rest, function(issue) { |
| 37 | 0 | issue.radius = range(issue.size); |
| 38 | 0 | return issue; |
| 39 | }); | |
| 40 | 0 | return [].concat(head, rest); |
| 41 | }, | |
| 42 | ideal: function(a, b, total) { | |
| 43 | 0 | var cutoff, d, days, length, m, now, once, velocity, y, _ref, _ref1; |
| 44 | 0 | if (b < a) { |
| 45 | 0 | _ref = [a, b], b = _ref[0], a = _ref[1]; |
| 46 | } | |
| 47 | 0 | _ref1 = _.map(a.match(config.data.chart.datetime)[1].split('-'), function(v) { |
| 48 | 0 | return parseInt(v); |
| 49 | }), y = _ref1[0], m = _ref1[1], d = _ref1[2]; | |
| 50 | 0 | cutoff = new Date(b); |
| 51 | 0 | days = []; |
| 52 | 0 | length = 0; |
| 53 | 0 | (once = function(inc) { |
| 54 | 0 | var day, day_of; |
| 55 | 0 | day = new Date(y, m - 1, d + inc); |
| 56 | 0 | if (!(day_of = day.getDay())) { |
| 57 | 0 | day_of = 7; |
| 58 | } | |
| 59 | 0 | if (__indexOf.call(config.data.chart.off_days, day_of) >= 0) { |
| 60 | 0 | days.push({ |
| 61 | date: day, | |
| 62 | off_day: true | |
| 63 | }); | |
| 64 | } else { | |
| 65 | 0 | length += 1; |
| 66 | 0 | days.push({ |
| 67 | date: day | |
| 68 | }); | |
| 69 | } | |
| 70 | 0 | if (!(day > cutoff)) { |
| 71 | 0 | return once(inc + 1); |
| 72 | } | |
| 73 | })(0); | |
| 74 | 0 | velocity = total / (length - 1); |
| 75 | 0 | days = _.map(days, function(day, i) { |
| 76 | 0 | day.points = total; |
| 77 | 0 | if (days[i] && !days[i].off_day) { |
| 78 | 0 | total -= velocity; |
| 79 | } | |
| 80 | 0 | return day; |
| 81 | }); | |
| 82 | 0 | if ((now = new Date) > cutoff) { |
| 83 | 0 | days.push({ |
| 84 | date: now, | |
| 85 | points: 0 | |
| 86 | }); | |
| 87 | } | |
| 88 | 0 | return days; |
| 89 | }, | |
| 90 | trend: function(actual, created_at, due_on) { | |
| 91 | 0 | var a, b, b1, c1, e, fn, intercept, l, last, now, slope, start, values; |
| 92 | 0 | if (!actual.length) { |
| 93 | 0 | return []; |
| 94 | } | |
| 95 | 0 | start = +actual[0].date; |
| 96 | 0 | values = _.map(actual, function(_arg) { |
| 97 | 0 | var date, points; |
| 98 | 0 | date = _arg.date, points = _arg.points; |
| 99 | 0 | return [+date - start, points]; |
| 100 | }); | |
| 101 | 0 | last = actual[actual.length - 1]; |
| 102 | 0 | values.push([+(new Date) - start, last.points]); |
| 103 | 0 | b1 = 0; |
| 104 | 0 | e = 0; |
| 105 | 0 | c1 = 0; |
| 106 | 0 | a = (l = values.length) * _.reduce(values, function(sum, _arg) { |
| 107 | 0 | var a, b; |
| 108 | 0 | a = _arg[0], b = _arg[1]; |
| 109 | 0 | b1 += a; |
| 110 | 0 | e += b; |
| 111 | 0 | c1 += Math.pow(a, 2); |
| 112 | 0 | return sum + (a * b); |
| 113 | }, 0); | |
| 114 | 0 | slope = (a - (b1 * e)) / ((l * c1) - (Math.pow(b1, 2))); |
| 115 | 0 | intercept = (e - (slope * b1)) / l; |
| 116 | 0 | fn = function(x) { |
| 117 | 0 | return slope * x + intercept; |
| 118 | }; | |
| 119 | 0 | created_at = new Date(created_at); |
| 120 | 0 | now = new Date; |
| 121 | 0 | if (due_on) { |
| 122 | 0 | due_on = new Date(due_on); |
| 123 | 0 | if (now > due_on) { |
| 124 | 0 | due_on = now; |
| 125 | } | |
| 126 | } else { | |
| 127 | 0 | due_on = now; |
| 128 | } | |
| 129 | 0 | a = created_at - start; |
| 130 | 0 | b = due_on - start; |
| 131 | 0 | return [ |
| 132 | { | |
| 133 | 'date': created_at, | |
| 134 | 'points': fn(a) | |
| 135 | }, { | |
| 136 | 'date': due_on, | |
| 137 | 'points': fn(b) | |
| 138 | } | |
| 139 | ]; | |
| 140 | } | |
| 141 | }; | |
| 142 | ||
| 143 | }).call(this); | |
| 144 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var async, calcSize, config, oneStatus, request, _; |
| 3 | ||
| 4 | 1 | _ = require('lodash'); |
| 5 | ||
| 6 | 1 | async = require('async'); |
| 7 | ||
| 8 | 1 | config = require('../../models/config.coffee'); |
| 9 | ||
| 10 | 1 | request = require('./request.coffee'); |
| 11 | ||
| 12 | 1 | module.exports = { |
| 13 | fetchAll: function(repo, cb) { | |
| 14 | 14 | return async.parallel([_.partial(oneStatus, repo, 'open'), _.partial(oneStatus, repo, 'closed')], function(err, _arg) { |
| 15 | 17 | var closed, open; |
| 16 | 17 | open = _arg[0], closed = _arg[1]; |
| 17 | 17 | return cb(err, { |
| 18 | open: open, | |
| 19 | closed: closed | |
| 20 | }); | |
| 21 | }); | |
| 22 | } | |
| 23 | }; | |
| 24 | ||
| 25 | 1 | calcSize = function(list) { |
| 26 | 0 | var issue, size, _i, _len; |
| 27 | 0 | switch (config.data.chart.points) { |
| 28 | case 'ONE_SIZE': | |
| 29 | 0 | size = list.length; |
| 30 | 0 | for (_i = 0, _len = list.length; _i < _len; _i++) { |
| 31 | 0 | issue = list[_i]; |
| 32 | 0 | issue.size = 1; |
| 33 | } | |
| 34 | 0 | break; |
| 35 | case 'LABELS': | |
| 36 | 0 | size = 0; |
| 37 | 0 | list = _.filter(list, function(issue) { |
| 38 | 0 | var labels; |
| 39 | 0 | if (!(labels = issue.labels)) { |
| 40 | 0 | return false; |
| 41 | } | |
| 42 | 0 | issue.size = _.reduce(labels, function(sum, label) { |
| 43 | 0 | var matches; |
| 44 | 0 | if (!(matches = label.name.match(config.data.chart.size_label))) { |
| 45 | 0 | return sum; |
| 46 | } | |
| 47 | 0 | return sum += parseInt(matches[1]); |
| 48 | }, 0); | |
| 49 | 0 | size += issue.size; |
| 50 | 0 | return !!issue.size; |
| 51 | }); | |
| 52 | } | |
| 53 | 0 | return { |
| 54 | list: list, | |
| 55 | size: size | |
| 56 | }; | |
| 57 | }; | |
| 58 | ||
| 59 | 1 | oneStatus = function(repo, state, cb) { |
| 60 | 28 | var done, fetchPage, results; |
| 61 | 28 | results = []; |
| 62 | 28 | done = function(err) { |
| 63 | 17 | if (err) { |
| 64 | 17 | return cb(err); |
| 65 | } | |
| 66 | 0 | return cb(null, calcSize(results)); |
| 67 | }; | |
| 68 | 28 | return (fetchPage = function(page) { |
| 69 | 28 | return request.allIssues(repo, { |
| 70 | state: state, | |
| 71 | page: page | |
| 72 | }, function(err, data) { | |
| 73 | 17 | if (err) { |
| 74 | 17 | return done(err); |
| 75 | } | |
| 76 | 0 | if (!data.length) { |
| 77 | 0 | return done(null, results); |
| 78 | } | |
| 79 | 0 | results = results.concat(_.sortBy(data, 'closed_at')); |
| 80 | 0 | if (data.length < 100) { |
| 81 | 0 | return done(null, results); |
| 82 | } | |
| 83 | 0 | return fetchPage(page + 1); |
| 84 | }); | |
| 85 | })(1); | |
| 86 | }; | |
| 87 | ||
| 88 | }).call(this); | |
| 89 |
| Line | Hits | Source |
|---|---|---|
| 1 | 2 | (function() { |
| 2 | 2 | var config, defaults, error, headers, isReady, isValid, ready, request, response, stack, superagent, user, _; |
| 3 | ||
| 4 | 2 | _ = require('lodash'); |
| 5 | ||
| 6 | 2 | superagent = require('superagent'); |
| 7 | ||
| 8 | 2 | require('../../utils/mixins.coffee'); |
| 9 | ||
| 10 | 2 | config = require('../../models/config.coffee'); |
| 11 | ||
| 12 | 2 | user = require('../../models/user.coffee'); |
| 13 | ||
| 14 | 2 | superagent.parse = { |
| 15 | 'application/json': function(res) { | |
| 16 | 17 | var e; |
| 17 | 17 | try { |
| 18 | 17 | return JSON.parse(res); |
| 19 | } catch (_error) { | |
| 20 | 17 | e = _error; |
| 21 | 17 | return {}; |
| 22 | } | |
| 23 | } | |
| 24 | }; | |
| 25 | ||
| 26 | 2 | defaults = { |
| 27 | 'github': { | |
| 28 | 'host': 'api.github.com', | |
| 29 | 'protocol': 'https' | |
| 30 | } | |
| 31 | }; | |
| 32 | ||
| 33 | 2 | module.exports = { |
| 34 | repo: function(_arg, cb) { | |
| 35 | 0 | var name, owner; |
| 36 | 0 | owner = _arg.owner, name = _arg.name; |
| 37 | 0 | if (!isValid({ |
| 38 | owner: owner, | |
| 39 | name: name | |
| 40 | })) { | |
| 41 | 0 | return cb('Request is malformed'); |
| 42 | } | |
| 43 | 0 | return ready(function() { |
| 44 | 0 | var data; |
| 45 | 0 | data = _.defaults({ |
| 46 | 'path': "/repos/" + owner + "/" + name, | |
| 47 | 'headers': headers(user.data.accessToken) | |
| 48 | }, defaults.github); | |
| 49 | 0 | return request(data, cb); |
| 50 | }); | |
| 51 | }, | |
| 52 | allMilestones: function(_arg, cb) { | |
| 53 | 1 | var name, owner; |
| 54 | 1 | owner = _arg.owner, name = _arg.name; |
| 55 | 1 | if (!isValid({ |
| 56 | owner: owner, | |
| 57 | name: name | |
| 58 | })) { | |
| 59 | 0 | return cb('Request is malformed'); |
| 60 | } | |
| 61 | 1 | return ready(function() { |
| 62 | 1 | var data; |
| 63 | 1 | data = _.defaults({ |
| 64 | 'path': "/repos/" + owner + "/" + name + "/milestones", | |
| 65 | 'query': { | |
| 66 | 'state': 'open', | |
| 67 | 'sort': 'due_date', | |
| 68 | 'direction': 'asc' | |
| 69 | }, | |
| 70 | 'headers': headers(user.data.accessToken) | |
| 71 | }, defaults.github); | |
| 72 | 1 | return request(data, cb); |
| 73 | }); | |
| 74 | }, | |
| 75 | oneMilestone: function(_arg, cb) { | |
| 76 | 3 | var milestone, name, owner; |
| 77 | 3 | owner = _arg.owner, name = _arg.name, milestone = _arg.milestone; |
| 78 | 3 | if (!isValid({ |
| 79 | owner: owner, | |
| 80 | name: name, | |
| 81 | milestone: milestone | |
| 82 | })) { | |
| 83 | 0 | return cb('Request is malformed'); |
| 84 | } | |
| 85 | 3 | return ready(function() { |
| 86 | 3 | var data; |
| 87 | 3 | data = _.defaults({ |
| 88 | 'path': "/repos/" + owner + "/" + name + "/milestones/" + milestone, | |
| 89 | 'query': { | |
| 90 | 'state': 'open', | |
| 91 | 'sort': 'due_date', | |
| 92 | 'direction': 'asc' | |
| 93 | }, | |
| 94 | 'headers': headers(user.data.accessToken) | |
| 95 | }, defaults.github); | |
| 96 | 3 | return request(data, cb); |
| 97 | }); | |
| 98 | }, | |
| 99 | allIssues: function(_arg, query, cb) { | |
| 100 | 30 | var milestone, name, owner; |
| 101 | 30 | owner = _arg.owner, name = _arg.name, milestone = _arg.milestone; |
| 102 | 30 | if (!isValid({ |
| 103 | owner: owner, | |
| 104 | name: name, | |
| 105 | milestone: milestone | |
| 106 | })) { | |
| 107 | 0 | return cb('Request is malformed'); |
| 108 | } | |
| 109 | 30 | return ready(function() { |
| 110 | 30 | var data; |
| 111 | 30 | data = _.defaults({ |
| 112 | 'path': "/repos/" + owner + "/" + name + "/issues", | |
| 113 | 'query': _.extend(query, { | |
| 114 | milestone: milestone, | |
| 115 | 'per_page': '100' | |
| 116 | }), | |
| 117 | 'headers': headers(user.data.accessToken) | |
| 118 | }, defaults.github); | |
| 119 | 30 | return request(data, cb); |
| 120 | }); | |
| 121 | } | |
| 122 | }; | |
| 123 | ||
| 124 | 2 | request = function(_arg, cb) { |
| 125 | 34 | var exited, headers, host, k, path, protocol, q, query, req, timeout, v; |
| 126 | 34 | protocol = _arg.protocol, host = _arg.host, path = _arg.path, query = _arg.query, headers = _arg.headers; |
| 127 | 34 | exited = false; |
| 128 | 34 | q = query ? '?' + ((function() { |
| 129 | 34 | var _results; |
| 130 | 34 | _results = []; |
| 131 | 34 | for (k in query) { |
| 132 | 128 | v = query[k]; |
| 133 | 128 | _results.push("" + k + "=" + v); |
| 134 | } | |
| 135 | 34 | return _results; |
| 136 | })()).join('&') : ''; | |
| 137 | 34 | req = superagent.get("" + protocol + "://" + host + path + q); |
| 138 | 34 | for (k in headers) { |
| 139 | 68 | v = headers[k]; |
| 140 | 68 | req.set(k, v); |
| 141 | } | |
| 142 | 34 | timeout = setTimeout(function() { |
| 143 | 1 | exited = true; |
| 144 | 1 | return cb('Request has timed out'); |
| 145 | }, config.data.request.timeout); | |
| 146 | 34 | return req.end(function(err, data) { |
| 147 | 23 | if (exited) { |
| 148 | 1 | return; |
| 149 | } | |
| 150 | 22 | exited = true; |
| 151 | 22 | clearTimeout(timeout); |
| 152 | 22 | return response(err, data, cb); |
| 153 | }); | |
| 154 | }; | |
| 155 | ||
| 156 | 2 | response = function(err, data, cb) { |
| 157 | 22 | var _ref; |
| 158 | 22 | if (err) { |
| 159 | 0 | return cb(error(err)); |
| 160 | } | |
| 161 | 22 | if (data.statusType !== 2) { |
| 162 | 19 | if ((data != null ? (_ref = data.body) != null ? _ref.message : void 0 : void 0) != null) { |
| 163 | 1 | return cb(data.body.message); |
| 164 | } | |
| 165 | 18 | return cb(data.error.message); |
| 166 | } | |
| 167 | 3 | return cb(null, data.body); |
| 168 | }; | |
| 169 | ||
| 170 | 2 | headers = function(token) { |
| 171 | 34 | var h; |
| 172 | 34 | h = { |
| 173 | 'Content-Type': 'application/json', | |
| 174 | 'Accept': 'application/vnd.github.v3' | |
| 175 | }; | |
| 176 | 34 | if (token != null) { |
| 177 | 0 | h.Authorization = "token " + token; |
| 178 | } | |
| 179 | 34 | return h; |
| 180 | }; | |
| 181 | ||
| 182 | 2 | isValid = function(obj) { |
| 183 | 34 | var key, rules, val; |
| 184 | 34 | rules = { |
| 185 | 'owner': function(val) { | |
| 186 | 34 | return val != null; |
| 187 | }, | |
| 188 | 'name': function(val) { | |
| 189 | 34 | return val != null; |
| 190 | }, | |
| 191 | 'milestone': function(val) { | |
| 192 | 33 | return _.isInt(val); |
| 193 | } | |
| 194 | }; | |
| 195 | 34 | for (key in obj) { |
| 196 | 101 | val = obj[key]; |
| 197 | 101 | if (key in rules && !rules[key](val)) { |
| 198 | 0 | return false; |
| 199 | } | |
| 200 | } | |
| 201 | 34 | return true; |
| 202 | }; | |
| 203 | ||
| 204 | 2 | isReady = user.data.ready; |
| 205 | ||
| 206 | 2 | stack = []; |
| 207 | ||
| 208 | 2 | ready = function(cb) { |
| 209 | 34 | if (isReady) { |
| 210 | 34 | return cb(); |
| 211 | } else { | |
| 212 | 0 | return stack.push(cb); |
| 213 | } | |
| 214 | }; | |
| 215 | ||
| 216 | 2 | user.observe('ready', function(val) { |
| 217 | 4 | var _results; |
| 218 | 4 | isReady = val; |
| 219 | 4 | if (val) { |
| 220 | 2 | _results = []; |
| 221 | 2 | while (stack.length) { |
| 222 | 0 | _results.push(stack.shift()()); |
| 223 | } | |
| 224 | 2 | return _results; |
| 225 | } | |
| 226 | }); | |
| 227 | ||
| 228 | 2 | error = function(err) { |
| 229 | 0 | var message; |
| 230 | 0 | switch (false) { |
| 231 | case !_.isString(err): | |
| 232 | 0 | message = err; |
| 233 | 0 | break; |
| 234 | case !_.isArray(err): | |
| 235 | 0 | message = err[1]; |
| 236 | 0 | break; |
| 237 | case !(_.isObject(err) && _.isString(err.message)): | |
| 238 | 0 | message = err.message; |
| 239 | } | |
| 240 | 0 | if (!message) { |
| 241 | 0 | try { |
| 242 | 0 | message = JSON.stringify(err); |
| 243 | } catch (_error) { | |
| 244 | 0 | message = err.toString(); |
| 245 | } | |
| 246 | } | |
| 247 | 0 | return message; |
| 248 | }; | |
| 249 | ||
| 250 | }).call(this); | |
| 251 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var Mediator, Ractive; |
| 3 | ||
| 4 | 1 | Ractive = require('ractive'); |
| 5 | ||
| 6 | 1 | Mediator = Ractive.extend({}); |
| 7 | ||
| 8 | 1 | module.exports = new Mediator(); |
| 9 | ||
| 10 | }).call(this); | |
| 11 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var moment, progress; |
| 3 | ||
| 4 | 1 | moment = require('moment'); |
| 5 | ||
| 6 | 1 | progress = function(a, b) { |
| 7 | 6 | if (a + b === 0) { |
| 8 | 0 | return 0; |
| 9 | } else { | |
| 10 | 6 | return 100 * (a / (b + a)); |
| 11 | } | |
| 12 | }; | |
| 13 | ||
| 14 | 1 | module.exports = function(milestone) { |
| 15 | 11 | var a, b, c, days, isDone, isEmpty, isOnTime, isOverdue, points, time; |
| 16 | 11 | isDone = false; |
| 17 | 11 | isOnTime = true; |
| 18 | 11 | isOverdue = false; |
| 19 | 11 | isEmpty = true; |
| 20 | 11 | points = 0; |
| 21 | 11 | a = milestone.issues.closed.size; |
| 22 | 5 | b = milestone.issues.open.size; |
| 23 | 5 | if (a + b > 0) { |
| 24 | 3 | isEmpty = false; |
| 25 | 3 | points = progress(a, b); |
| 26 | 3 | if (points === 100) { |
| 27 | 1 | isDone = true; |
| 28 | } | |
| 29 | } | |
| 30 | 5 | if (milestone.due_on == null) { |
| 31 | 2 | return { |
| 32 | isOverdue: isOverdue, | |
| 33 | isOnTime: isOnTime, | |
| 34 | isDone: isDone, | |
| 35 | isEmpty: isEmpty, | |
| 36 | 'progress': { | |
| 37 | points: points | |
| 38 | } | |
| 39 | }; | |
| 40 | } | |
| 41 | 3 | a = +new Date(milestone.created_at); |
| 42 | 3 | b = +(new Date); |
| 43 | 3 | c = +new Date(milestone.due_on); |
| 44 | 3 | if (b > c) { |
| 45 | 1 | isOverdue = true; |
| 46 | } | |
| 47 | 3 | time = progress(b - a, c - b); |
| 48 | 3 | days = (moment(b).diff(moment(a), 'days')) / 100; |
| 49 | 3 | isOnTime = points > time; |
| 50 | 3 | return { |
| 51 | isDone: isDone, | |
| 52 | days: days, | |
| 53 | isOnTime: isOnTime, | |
| 54 | isOverdue: isOverdue, | |
| 55 | 'progress': { | |
| 56 | points: points, | |
| 57 | time: time | |
| 58 | } | |
| 59 | }; | |
| 60 | }; | |
| 61 | ||
| 62 | }).call(this); | |
| 63 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var _; |
| 3 | ||
| 4 | 1 | _ = require('lodash'); |
| 5 | ||
| 6 | 1 | _.mixin({ |
| 7 | 'pluckMany': function(source, keys) { | |
| 8 | 12 | if (!_.isArray(keys)) { |
| 9 | 0 | throw '`keys` needs to be an Array'; |
| 10 | } | |
| 11 | 12 | return _.map(source, function(item) { |
| 12 | 6 | var obj; |
| 13 | 6 | obj = {}; |
| 14 | 6 | _.each(keys, function(key) { |
| 15 | 12 | return obj[key] = item[key]; |
| 16 | }); | |
| 17 | 6 | return obj; |
| 18 | }); | |
| 19 | }, | |
| 20 | 'isInt': function(val) { | |
| 21 | 33 | return !isNaN(val) && parseInt(Number(val)) === val && !isNaN(parseInt(val, 10)); |
| 22 | } | |
| 23 | }); | |
| 24 | ||
| 25 | }).call(this); | |
| 26 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var Ractive, mediator, _; |
| 3 | ||
| 4 | 1 | _ = require('lodash'); |
| 5 | ||
| 6 | 1 | Ractive = require('ractive'); |
| 7 | ||
| 8 | 1 | mediator = require('../../modules/mediator.coffee'); |
| 9 | ||
| 10 | 1 | module.exports = Ractive.extend({ |
| 11 | subscribe: function(name, cb, ctx) { | |
| 12 | 2 | if (ctx == null) { |
| 13 | 0 | ctx = this; |
| 14 | } | |
| 15 | 2 | if (!_.isArray(this._subs)) { |
| 16 | 1 | this._subs = []; |
| 17 | } | |
| 18 | 2 | if (_.isFunction(cb)) { |
| 19 | 2 | return this._subs.push(mediator.on(name, _.bind(cb, ctx))); |
| 20 | } else { | |
| 21 | 0 | return console.log("Warning: `cb` is not a function"); |
| 22 | } | |
| 23 | }, | |
| 24 | publish: function() { | |
| 25 | 0 | return mediator.fire.apply(mediator, arguments); |
| 26 | }, | |
| 27 | onteardown: function() { | |
| 28 | 0 | var sub, _i, _len, _ref, _results; |
| 29 | 0 | if (_.isArray(this._subs)) { |
| 30 | 0 | _ref = this._subs; |
| 31 | 0 | _results = []; |
| 32 | 0 | for (_i = 0, _len = _ref.length; _i < _len; _i++) { |
| 33 | 0 | sub = _ref[_i]; |
| 34 | 0 | if (_.isFunction(sub.cancel)) { |
| 35 | 0 | _results.push(sub.cancel()); |
| 36 | } else { | |
| 37 | 0 | _results.push(console.log("Warning: `sub.cancel` is not a function")); |
| 38 | } | |
| 39 | } | |
| 40 | 0 | return _results; |
| 41 | } | |
| 42 | } | |
| 43 | }); | |
| 44 | ||
| 45 | }).call(this); | |
| 46 |
| Line | Hits | Source |
|---|---|---|
| 1 | 1 | (function() { |
| 2 | 1 | var Eventful; |
| 3 | ||
| 4 | 1 | Eventful = require('./eventful.coffee'); |
| 5 | ||
| 6 | 1 | module.exports = function(opts) { |
| 7 | 3 | var Model, model; |
| 8 | 3 | Model = Eventful.extend(opts); |
| 9 | 3 | model = new Model(); |
| 10 | 3 | model.render(); |
| 11 | 3 | return model; |
| 12 | }; | |
| 13 | ||
| 14 | }).call(this); | |
| 15 |