notes-cli 1.1.0 → 2.0.0

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/../lib/notes-cli'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end

data/spec/stats_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'tempfile'
+
+describe 'stats' do
+  context 'compute' do
+    let(:file)    { Tempfile.new('example') }
+    let(:options) { Notes::Options.defaults }
+    let(:tasks)   { Notes::Tasks.for_file(file.path, options[:flags]) }
+
+    before do
+      File.open(file, 'w') do |f|
+        f.write "TODO: one\n"
+        f.write "two\n"
+        f.write "TODO: three\n"
+        f.write "OPTIMIZE: four\n"
+        f.write "five\n"
+        f.write "six\n"
+        f.write "seven FIXME\n"
+      end
+    end
+
+    it 'counts stats correctly' do
+      Notes::Stats.flag_counts(tasks).should == {
+        'TODO' => 2,
+        'OPTIMIZE' => 1,
+        'FIXME'  => 1
+      }
+    end
+
+    it 'aggregates found flags' do
+      Notes::Stats.found_flags(tasks).should == ['TODO', 'OPTIMIZE', 'FIXME']
+    end
+  end
+end

data/spec/tasks_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'tempfile'
+
+describe 'tasks' do
+
+  context 'matching_flags' do
+    specify do
+      Notes::Tasks.matching_flags("TODO: foo", ["TODO"]).should == ["TODO"]
+    end
+
+    specify do
+      Notes::Tasks.matching_flags("TODO: bar", ["FIXME"]).should == []
+    end
+
+    specify do
+      Notes::Tasks.matching_flags("fixme", ["FIXME", "foo"]).should == ["FIXME"]
+    end
+
+    specify do
+      Notes::Tasks.matching_flags("TODO: foo FIXME", ["TODO","FIXME", "OPTIMIZE"])
+        .should == ["TODO","FIXME"]
+    end
+  end
+
+  context 'for_file' do
+    let(:file)    { Tempfile.new('example') }
+    let(:options) { Notes::Options.defaults }
+    let(:tasks)   { Notes::Tasks.for_file(file.path, options[:flags]) }
+
+    before do
+      File.open(file, 'w') do |f|
+        f.write "TODO: one\n"
+        f.write "two\n"
+        f.write "three\n"
+        f.write "findme: four\n"
+        f.write "five\n"
+        f.write "six\n"
+        f.write "seven FIXME\n"
+      end
+    end
+
+    specify { tasks.length.should == 2 }
+
+    it 'counts custom flags correctly' do
+      tasks = Notes::Tasks.for_file(file.path, options[:flags] + ["FINDME"])
+      tasks.length.should == 3
+    end
+
+    it 'parses lines correctly' do
+      tasks = Notes::Tasks.for_file(file.path, options[:flags] + ["FINDME"])
+      t0, t1, t2 = tasks
+
+      t0.line_num.should == 1
+      t0.line.should == "TODO: one"
+      t0.flags.should == ["TODO"]
+      t0.context.should == "two\nthree\nfindme: four\nfive\nsix"
+
+      t1.line_num.should == 4
+      t1.line.should == "findme: four"
+      t1.flags.should == ["FINDME"]
+      t1.context.should == "five\nsix\nseven FIXME"
+
+      t2.line_num.should == 7
+      t2.line.should == "seven FIXME"
+      t2.flags.should == ["FIXME"]
+      t2.context.should == ""
+    end
+
+    # This is kind of annoying - we have a perfectly valid file to parse,
+    # but it's not in a git repo. We could build an abstraction layer over
+    # the git call, but that doesn't seem worth it, so hand-wave the git parts
+    # and test simple field parsing
+    #
+    # Also directly testing private methods, somebody call the TDD police
+    it 'reads information from git' do
+      Notes.should_receive(:blame).and_return({
+        "author" => "Andrew Berls",
+        "author-time" => "1381862180",
+        "sha" => "705690fb747a2ae82a96edb21df7e424f5cc518b",
+      })
+
+      info = Notes::Tasks.send(:line_info, 'doesnt_matter_stubbed_out', 0)
+      info[:author].should == 'Andrew Berls'
+      info[:date].should == '2013-10-15 11:36:20 -0700'
+      info[:sha].should == '705690fb747a2ae82a96edb21df7e424f5cc518b'
+    end
+  end
+
+end
+

data/web/assets/javascripts/application.js

@@ -0,0 +1,438 @@
+// Change underscore templates to {{}} and {{= }} to play nice with ERB
+_.templateSettings = {
+  interpolate: /\{\{\=(.+?)\}\}/g,
+  evaluate: /\{\{(.+?)\}\}/g
+};
+
+
+// Global namespace object
+window.Notes = {};
+
+
+Notes.escapeHtml = function(text) {
+  return $('<div>').text(text).html();
+}
+
+
+// Is Array A a subset of Array B?
+Notes.isSubset = function(a,b) {
+  return a.length === _.intersection(a,b).length;
+}
+
+
+// How many tabs or spaces does a string start with?
+Notes.leadingWhitespaceCount = function(str) {
+  var count = 0;
+  while(str.charAt(0) === " " || str.charAt(0) === "\t") {
+    str = str.substr(1);
+    count++;
+  }
+  return count;
+}
+
+
+// Take an array of lines and return the smallest number of leading whitespaces
+// (tabs or spaces) from among them
+Notes.minLtrim = function(lines) {
+  var counts = lines.map(function(line) { return Notes.leadingWhitespaceCount(line); })
+  return Math.min.apply(null, counts);
+}
+
+
+Notes.defaultFlags = ['TODO', 'OPTIMIZE', 'FIXME'];
+
+
+Notes.getSelectedFlags = function() {
+  return Notes.sidebarView.collection
+    .filter(function(f) { return f.get('checked'); })
+    .map(function(f) { return f.get('name') });
+}
+
+
+// Color classes to be paired against distinct flags (for consistency)
+Notes.colors = [
+  'lightblue','purple','fuschia','lightgreen','orange','green','blue',
+  'pink','turquoise','deepred',
+]
+
+// TODO
+Notes.buildColorMap = function(flags) {
+  var allFlags   = _.uniq(flags.concat(Notes.defaultFlags));
+  Notes.colorMap = _.zip(allFlags, Notes.colors);
+}
+
+
+Notes.colorFor = function(flagName) {
+  var map;
+  for (var i=0; i<Notes.colorMap.length; i++) {
+    map = Notes.colorMap[i];
+    if (map[0] === flagName) {
+      return map[1];
+    } else if (map[0] === undefined) {
+      // No existing mapping found - add new flag to colorMap
+      map[0] = flagName;
+      return map[1];
+    }
+  }
+
+  return Notes.colors[Notes.colors.length-1]; // TODO - default to last color in list
+}
+
+
+
+Notes.Task = Backbone.Model.extend({
+  escapedLine: function() {
+    return Notes.escapeHtml(this.get('line'));
+  },
+
+  escapedContextLines: function() {
+    var ctx = this.get('context');
+    if (ctx === '') { return []; }
+
+    return ctx.split("\n")
+               .map(function(line) { return Notes.escapeHtml(line); });
+  },
+
+  allLines: function() {
+    return [this.escapedLine()].concat(this.escapedContextLines());
+  },
+
+  highlightedLine: function() {
+    var regex = new RegExp(this.get('flags').join('|'), 'gi');
+    return this.escapedLine().replace(regex, function(flag) {
+      return "<strong>"+flag+"</strong>";
+    });
+  },
+
+  formattedSha: function() {
+    var sha = this.get('sha');
+    return sha ? "@ " + sha.slice(0,7) : '';
+  },
+
+  formattedDate: function() {
+    var date  = new Date(this.get('date')),
+        month = date.getMonth() + 1,
+        day   = date.getDate(),
+        year  = date.getFullYear().toString().slice(2);
+
+    return month + '/' + day + '/' + year;
+  }
+});
+
+
+// A view for a single task item
+Notes.TaskView = Backbone.View.extend({
+  tagName: 'div',
+  className: 'task',
+  template: _.template($('#tmpl-task').html()),
+
+  render: function() {
+    $(this.el).html(this.template({ task: this.model }));
+    return this;
+  },
+
+  events: {
+    'click .task-toggle': 'toggleContext'
+  },
+
+  toggleContext: function() {
+    var $el = $(this.el),
+        $toggle = $el.find('.task-toggle'),
+        $ctx    = $el.find('.task-context');
+
+    if ($ctx.is(':visible')) {
+      $toggle.removeClass('fa-angle-up').addClass('fa-angle-down');
+      $ctx.slideUp();
+    } else {
+      $toggle.removeClass('fa-angle-down').addClass('fa-angle-up');
+      $ctx.slideDown();
+    }
+  }
+});
+
+
+Notes.TasksCollection = Backbone.Collection.extend({
+  model: Notes.Task,
+
+  initialize: function() {
+    this.filename = '';
+  }
+});
+
+
+// A view for a collection of tasks grouped under a common filename
+Notes.TaskCollectionView = Backbone.View.extend({
+  tagName: 'div',
+  classname: 'tasks-container',
+
+  render: function() {
+    var $el = $(this.el);
+    $el.append("<h2 class='task-filename'>"+this.collection.filename+":</h2>");
+
+    this.collection.each(function(task) {
+      $el.append(new Notes.TaskView({ model: task }).render().el);
+    });
+    return this;
+  }
+});
+
+
+
+// A flag accompanied by a checkbox in the sidebar
+Notes.Flag = Backbone.Model.extend({
+  defaults: { checked: true },
+
+  checkedClass: function() { return this.get('checked') ? 'checked' : ''; }
+});
+
+
+Notes.FlagView = Backbone.View.extend({
+  tagName: 'div',
+  className: 'flag-container',
+  template: _.template($('#tmpl-flag').html()),
+
+  render: function() {
+    $(this.el).html(this.template({ flag: this.model }));
+    return this;
+  },
+
+  events: {
+    'click .checkbox': 'toggleCheck',
+    'click .delete-flag-btn': 'deleteFlag'
+  },
+
+  $checkbox: function() { return $(this.el).find('.checkbox'); },
+  isChecked: function() { return this.$checkbox().hasClass('checked'); },
+  check: function() {
+    this.model.set('checked', true);
+    this.$checkbox().addClass('checked');
+  },
+  uncheck: function() {
+    this.model.set('checked', false);
+    this.$checkbox().removeClass('checked');
+  },
+  toggleCheck: function() { this.isChecked() ? this.uncheck() : this.check(); },
+
+  deleteFlag: function() {
+    Notes.sidebarView.collection.remove(this.model);
+    var $el = $(this.el);
+    $el.slideUp(200, function() { $el.remove(); });
+  }
+});
+
+
+Notes.FlagCollection = Backbone.Collection.extend({
+  model: Notes.Flag,
+
+  // Add a flag into the collection unless it's already present
+  merge: function(flag) {
+    var attrs = { name: flag.toUpperCase() }
+        match = this.findWhere(attrs);
+    if (!match) { this.add(attrs); }
+  }
+});
+
+
+Notes.FlagCollectionView = Backbone.View.extend({
+  tagName: 'div',
+
+  render: function() {
+    var $el = $(this.el);
+    $el.html('');
+
+    this.collection.each(function(flag) {
+      $el.append(new Notes.FlagView({ model: flag }).render().el);
+    });
+    return this;
+  }
+});
+
+
+
+// Merge a custom flag into the sidebar and re-render
+Notes.addFlag = function(flag) {
+  if (flag === '') { return false; }
+  Notes.sidebarView.collection.merge(flag);
+  Notes.renderSidebar();
+}
+
+
+// Build (or rebuild) the sidebar from the flags
+// used to query the server
+Notes.buildSidebar = function(flags) {
+  var attrs = flags.map(function(f) { return { name: f }; });
+
+  Notes.sidebarView = new Notes.FlagCollectionView({
+    collection: new Notes.FlagCollection(attrs)
+  });
+  Notes.renderSidebar();
+}
+
+// TODO: calling this more than once breaks click handlers ???
+Notes.renderSidebar = function() {
+  var $container = $('.flags-container');
+  $container.empty();
+  $container.append(Notes.sidebarView.render().el);
+}
+
+
+Notes.renderStats = function(stats) {
+  var flagCounts = stats.flag_counts;
+
+  // TODO: add in stats container
+  //   <div class="stats-container">
+  //     <div class="chart"></div>
+  //   </div>
+}
+
+
+// tasks - Array[Notes.Task]
+Notes.renderTasks = function(tasks) {
+  var $container = $('.main-content-container'),
+      filename, collection, collectionView;
+
+  $container.empty();
+
+  if (tasks.length === 0) {
+    $container.html($("<div class='empty-tasks-container'>").append(
+      "<h2>No tasks matching the criteria were found!</h2>"));
+    return;
+  }
+
+  // filename -> Array[Notes.Task]
+  var taskMap = _.groupBy(tasks, function(t) { return t.get('filename'); });
+
+  for (filename in taskMap) {
+    collection = new Notes.TasksCollection(taskMap[filename]);
+    collection.filename   = filename;
+
+    collectionView = new Notes.TaskCollectionView({ collection: collection })
+    $container.append(collectionView.render().el);
+  }
+}
+
+
+Notes.addProgress = function() {
+  $('.loading-container').find('p').append('.');
+}
+
+
+
+// Check if a set of tasks can be filtered based on flags we've already searched for
+// This allows us to avoid hitting the server when we don't need to
+//
+// flags - Array[String]
+Notes.isSubsetQuery = function(flags) {
+  return Notes.isSubset(flags, Notes.lastQueryFlags);
+}
+
+
+// Find a subset of locally-cached tasks that match a set of search flags
+// Returns Array[Notes.Task]
+//
+// TODO: this behaves weirdly if a task has multiple flags, punting for now
+Notes.filterTasks = function(queryFlags) {
+  if (queryFlags.length === 0) { return []; }
+
+  return Notes.tasks.filter(function(task) {
+    var taskFlags = task.get('flags');
+    return (Notes.isSubset(taskFlags, queryFlags) ||
+            Notes.isSubset(queryFlags, taskFlags));
+  });
+}
+
+
+// Returns the URL to query the server at
+Notes.queryPath = function() {
+  var path = window.location.pathname;
+  return (path === '/' ? '' : path) + "/tasks.json"
+}
+
+
+// Fetch tasks from the server and re-render
+Notes.queryTasks = function(queryFlags) {
+  if (!Notes.colorMap) { Notes.buildColorMap(queryFlags); }
+
+  if (Notes.lastQueryFlags && Notes.isSubsetQuery(queryFlags)) {
+    // Subset query - don't need to hit server
+    var tasks = Notes.filterTasks(queryFlags);
+    Notes.renderTasks(tasks);
+    return;
+  }
+
+  // Can't filter client-side - need to hit server
+  $('.main-content-container').html("<div class='loading-container'><p>Loading </p></div>");
+  var progressInterval = setInterval(Notes.addProgress, 175);
+
+  if (!Notes.sidebarView) { Notes.buildSidebar(queryFlags); }
+
+  $.getJSON(Notes.queryPath(), { flags: queryFlags }, function(json) {
+    var stats = json.stats,
+        tasks = json.tasks.map(function(attrs) { return new Notes.Task(attrs) });
+
+    Notes.tasks = tasks;
+    Notes.lastQueryFlags = queryFlags; // Save the most recent search terms for checking subsets
+
+    clearInterval(progressInterval);
+    Notes.renderStats(stats);
+    Notes.renderTasks(tasks);
+
+  });
+}
+
+
+
+// Page Load
+// ----------------------------------
+Notes.queryTasks(Notes.defaultFlags);
+
+
+$(function() {
+  var $doc = $(document);
+
+  $doc.on('keyup', '.add-flag', function(e) {
+    if (e.keyCode === 13) {
+      var $input = $(this);
+      Notes.addFlag($input.val());
+      $input.val('');
+    }
+  });
+
+
+  $doc.on('click', '.add-flag-btn', function() {
+    var $input = $('.add-flag');
+    Notes.addFlag($input.val());
+    $input.val('');
+    return false;
+  });
+
+
+  $doc.on('click', '.filter-btn', function() {
+    Notes.queryTasks(Notes.getSelectedFlags());
+    return false;
+  });
+
+
+  $doc.on('click', '.restore-defaults-btn', function() {
+    Notes.queryTasks(Notes.defaultFlags);
+    return false;
+  });
+
+
+  $doc.on('click', '.toggle-all-context-btn', function() {
+    var $toggle = $('.task-toggle'),
+        $ctx    = $('.task-context');
+
+    if ($ctx.is(':visible')) {
+      $(this).html("Show all context <i class='fa fa-angle-down'></i>");
+      $toggle.removeClass('fa-angle-up').addClass('fa-angle-down');
+      $ctx.slideUp();
+    } else {
+      $(this).html("Hide all context <i class='fa fa-angle-up'></i>");
+      $toggle.removeClass('fa-angle-down').addClass('fa-angle-up');
+      $ctx.slideDown();
+    }
+
+    return false;
+  });
+});