notes-cli 1.1.0 → 2.0.0

data/lib/notes-cli/server.rb

@@ -0,0 +1,34 @@
+require 'rack'
+require 'optparse'
+require 'notes-cli/web'
+
+module Notes
+  class Server
+    SERVER_DEFAULTS = {
+      :Host => '127.0.0.1',
+      :Port => '9292'
+    }
+
+    def initialize(argv)
+      @options = SERVER_DEFAULTS.merge(parse_options(argv))
+    end
+
+    def parse_options(args)
+      options = {}
+      OptionParser.new do |opts|
+        opts.on('-p', '--port [PORT]', 'The port to run on') do |port|
+          options[:Port] = port
+        end
+      end.parse!(args)
+
+      options
+    end
+
+    def start
+      Rack::Handler::WEBrick.run(Notes::Web, @options) do |server|
+          [:INT, :TERM].each { |sig| trap(sig) { server.stop } }
+      end
+    end
+
+  end
+end

data/lib/notes-cli/stats.rb

@@ -0,0 +1,40 @@
+require 'set'
+
+module Notes
+  module Stats
+    extend self
+
+    def compute(tasks)
+      {
+        flag_counts: flag_counts(tasks),
+        found_flags: found_flags(tasks)
+      }
+    end
+
+    # Take in a set of tasks and compute aggregate stats such as counts per
+    # flag. Intended to augment a JSON set
+    #
+    # tasks: Array[Notes::Task]
+    #
+    # Returns Hash
+    def flag_counts(tasks)
+      counts = Hash.new(0)
+      tasks.each do |task|
+        task.flags.each { |flag| counts[flag] += 1 }
+      end
+      counts
+    end
+
+    # Compute the distinct flags found in a a set of tasks
+    #
+    # tasks: Array[Notes::Task]
+    #
+    # Returns Array[String] of flag names
+    def found_flags(tasks)
+      flags = Set.new
+      tasks.each { |task| flags.merge(task.flags) }
+      flags.to_a
+    end
+
+  end
+end

data/lib/notes-cli/tasks.rb

@@ -0,0 +1,170 @@
+module Notes
+
+  class Task
+    attr_accessor :author, :date, :filename, :line_num,
+                  :line, :flags, :context
+
+    def initialize(options={})
+      @author   = options[:author]
+      @date     = options[:date]
+      @sha      = options[:sha]
+      @filename = options[:filename]
+      @line_num = options[:line_num]
+      @line     = options[:line]
+      @flags    = options[:flags]
+      @context  = options[:context]
+    end
+
+    # Return a String in a format suitable for printing
+    # to the console that includes the line number
+    # and matched flag highlighted in color
+    #
+    # TODO: different colors for different flags
+    def to_s
+      flag_regex = Regexp.new(@flags.join('|'), true)
+      line  = @line.gsub(flag_regex) do |flag|
+        Notes.colorize('yellow', flag)
+      end
+
+      "ln #{@line_num}: #{line.strip}"
+    end
+
+    def to_json
+      {
+       filename: @filename,
+       line_num: @line_num,
+       line:     @line,
+       flags:    @flags,
+       context:  @context,
+       author:   @author,
+       date:     @date,
+       sha:      @sha
+      }
+    end
+  end
+
+
+  module Tasks
+    extend self
+
+    # Return array of flags matched in a line
+    #
+    # line - A String to match against
+    # flags - An Array of String flags to search for
+    #
+    # Returns Array of string flags found
+    def matching_flags(line, flags)
+      words = line.split(/\W/).map(&:upcase)
+      words & flags.map(&:upcase)
+    end
+
+    # Parse a file and construct Task objects for each line matching
+    # one of the patterns specified in `flags`
+    #
+    # filename - A String filename to read
+    # flags - Array of String flags to match against
+    #
+    # Returns Array<Notes::Task>
+    def for_file(filename, flags)
+      counter = 1
+      tasks   = []
+
+      begin
+        lines = File.readlines(filename).map(&:chomp)
+
+        lines.each_with_index do |line, idx|
+          matched_flags = matching_flags(line, flags)
+
+          if matched_flags.any?
+            task_options = {
+              filename: Notes.shortname(filename),
+              line_num: counter,
+              line: line,
+              flags: matched_flags,
+              context: context_lines(lines, idx)
+            }
+            # Extract line information from git
+            info = line_info(filename, idx)
+            task_options[:author] = info[:author]
+            task_options[:date]   = info[:date]
+            task_options[:sha]    = info[:sha]
+            tasks << Notes::Task.new(task_options)
+          end
+          counter += 1
+        end
+      rescue
+        # Error occurred reading the file (ex: invalid byte sequence in UTF-8)
+        # Move on quietly
+      end
+
+      tasks
+    end
+
+    # Compute all tasks for a set of files and flags
+    #
+    # files   - Array of String filenames
+    # options - Hash of options
+    #   :flags - Array of String flags to match against
+    #
+    # Returns Array[Notes::Task]
+    def for_files(files, options)
+      flags  = options[:flags]
+      result = []
+      files.each do |filename|
+        tasks = Notes::Tasks.for_file(filename, flags)
+        result += tasks
+      end
+
+      result
+    end
+
+    # Return list of tasks for the provided options
+    # If no options are provided, will use default
+    # file locations and flags
+    #
+    # Returns Array[Notes::Task]
+    def all(options = Notes::Options.defaults)
+      files = Notes.valid_files(options)
+      for_files(files, options)
+    end
+
+    private
+
+    # Return up to 5 lines following the line at idx
+    # TODO: it might be better to have before_context and after_context
+    def context_lines(lines, idx)
+      ctx = []
+      1.upto(5) do |i|
+        num = idx+i
+        break unless lines[num]
+        ctx << lines[num]
+      end
+      ctx.join("\n")
+    end
+
+    # Information about a line from git (author, date, etc)
+    #
+    # filename - A String filename
+    # idx - a 0-based line number
+    #
+    # Returns Hash
+    def line_info(filename, idx)
+      result = {}
+      return result unless Notes.git?
+
+      fields = Notes.blame(filename, idx+1)
+
+      author = fields["author"]
+      result[:author] = author if author && !author.empty?
+
+      time = fields["author-time"] # ISO 8601
+      result[:date] = Time.at(time.to_i).to_s if time && !time.empty?
+
+      sha = fields["sha"]
+      result[:sha] = sha if sha
+
+      result
+    end
+  end
+
+end

data/lib/notes-cli/version.rb

@@ -1,3 +1,3 @@
 module Notes
-  VERSION = "1.1.0"
+  VERSION = '2.0.0'
 end

data/lib/notes-cli/web.rb

@@ -0,0 +1,39 @@
+require 'sinatra'
+require 'json'
+
+# A web dashboard for annotations
+# This is intended to be mounted within an application, e.g.
+#
+#   mount Notes::Web => '/notes'
+#
+module Notes
+  class Web < Sinatra::Base
+
+    set :root, File.expand_path(File.dirname(__FILE__) + "/../../web")
+    set :public_folder, Proc.new { "#{root}/assets" }
+    set :views, Proc.new { "#{root}/views" }
+
+    get '/' do
+      # TODO: there has to be a better way to get the mounted root
+      @root = request.env["SCRIPT_NAME"]
+
+      erb :index
+    end
+
+    get '/tasks.json' do
+      # TODO: cache this somehow
+      options = Notes::Options.defaults
+
+      if flags = params[:flags]
+        options[:flags] = flags
+      end
+
+      tasks  = Notes::Tasks.all(options)
+      @stats = Notes::Stats.compute(tasks)
+      @tasks = tasks.map(&:to_json)
+
+      { stats: @stats, tasks: @tasks }.to_json
+    end
+
+  end
+end

data/notes-cli.gemspec

@@ -0,0 +1,23 @@
+require File.expand_path('../lib/notes-cli/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'notes-cli'
+  s.date        = '2013-01-13'
+  s.summary     = "A tool for managing source code annotations"
+  s.description = %q{
+    notes-cli lets you manage source code annotations such as
+    todo or fixme comments, providing a command-line interface as well as a web
+    dashboard.
+  }.strip.gsub(/\s+/, ' ')
+  s.authors     = ["Andrew Berls"]
+  s.email       = 'andrew.berls@gmail.com'
+  s.homepage    = 'https://github.com/andrewberls/notes-cli'
+  s.license     = 'MIT'
+
+  s.executables << 'notes'
+  s.files       = `git ls-files`.split($/)
+  s.version     = Notes::VERSION
+
+  s.add_runtime_dependency 'sinatra'
+  s.add_development_dependency 'rspec', '~> 2.14.1'
+end

data/spec/notes_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Notes' do
+
+  context 'shortname' do
+    specify do
+      Dir.should_receive(:pwd).and_return('/path/to/notes-cli')
+      Notes.shortname('/path/to/notes-cli/bin/notes').should == 'bin/notes'
+    end
+  end
+
+end

data/spec/options_spec.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'arg groups' do
+  context 'with no options' do
+    it "accepts a list of files" do
+      Notes::Options.arg_groups(['one.rb', 'two.rb']).should == [['one.rb', 'two.rb']]
+    end
+
+    it "accepts a directory" do
+      Notes::Options.arg_groups(['app/']).should == [['app/']]
+    end
+
+    it "looks in the current directory if none provided" do
+      Notes::Options.arg_groups(['-f', 'src/']).should == [[Dir.pwd], ['-f', 'src/']]
+    end
+  end
+
+  context 'with options' do
+    it "accepts a list of files" do
+      ['-f', '--flags'].each do |flag|
+        Notes::Options.arg_groups(['one.rb', 'two.rb', flag, 'broken']).should == [['one.rb', 'two.rb'], [flag, 'broken']]
+      end
+    end
+
+    it "accepts a directory" do
+      ['-e', '--exclude'].each do |flag|
+        Notes::Options.arg_groups(['app/', flag, 'log/']).should == [['app/'], [flag, 'log/']]
+      end
+    end
+
+    it "groups flags correctly" do
+      Notes::Options.arg_groups(['app/', '-f', 'broken', '-e', 'log/']).should == [['app/'], ['-f', 'broken'], ['-e', 'log/']]
+      Notes::Options.arg_groups(['one.rb', 'two.rb', '-e', 'tmp', '-f', 'findme']).should == [['one.rb', 'two.rb'], ['-e', 'tmp'], ['-f', 'findme']]
+    end
+
+    it "accepts mixed length flags" do
+      expected = [['one.rb', 'two.rb'], ['--exclude', 'tmp'], ['-f', 'findme']]
+      Notes::Options.arg_groups(['one.rb', 'two.rb', '--exclude', 'tmp', '-f', 'findme']).should == expected
+    end
+
+    it "handles multiple flag arguments" do
+      expected = [['src/'], ['-f', 'broken', 'findme'], ['-e', 'log/', 'tmp/']]
+      Notes::Options.arg_groups(['src/', '-f', 'broken', 'findme', '-e', 'log/', 'tmp/']).should == expected
+    end
+  end
+end
+
+
+describe "opt parsing" do
+  context 'with no options' do
+    it "accepts a list of files" do
+      files = ['one.rb', 'two.rb']
+      opts = Notes::Options.parse(files)
+      opts[:locations].should == files
+    end
+
+    it "accepts a directory" do
+      opts = Notes::Options.parse(['app/'])
+      opts[:locations].should == ['app/']
+    end
+
+    it "looks in the current directory if none provided" do
+      opts = Notes::Options.parse(['-f', 'src/'])
+      opts[:flags].should include('src')
+    end
+  end
+
+  context 'with options' do
+    it "accepts a list of files" do
+      ['-f', '--flags'].each do |flag|
+        opts = Notes::Options.parse(['one.rb', 'two.rb', flag, 'broken'])
+        opts[:locations].should == ['one.rb', 'two.rb']
+        opts[:flags].should include('broken')
+      end
+    end
+
+    it "accepts a directory" do
+      ['-e', '--exclude'].each do |flag|
+        opts = Notes::Options.parse(['app/', flag, 'log/'])
+        opts[:exclude].should include('log')
+      end
+    end
+
+    it "groups flags correctly" do
+      opts = Notes::Options.parse(['app/', '-f', 'broken', '-e', 'log/'])
+      opts[:flags].should include('broken')
+      opts[:exclude].should include('log')
+
+      opts = Notes::Options.parse(['one.rb', 'two.rb', '-e', 'tmp', '-f', 'findme'])
+      opts[:flags].should include('findme')
+      opts[:exclude].should include('tmp')
+    end
+
+    it "accepts mixed length flags" do
+      opts = Notes::Options.parse(['one.rb', 'two.rb', '--exclude', 'tmp', '-f', 'findme'])
+      opts[:flags].should include('findme')
+      opts[:exclude].should include('tmp')
+    end
+
+    it "handles multiple flag arguments" do
+      opts = Notes::Options.parse(['src/', '-f', 'broken', 'findme', '-e', 'log/', 'tmp/'])
+      opts[:flags].should include('broken', 'findme')
+      opts[:exclude].should include('log', 'tmp')
+    end
+  end
+end
+
+describe 'defaults' do
+  context 'when Rails is not defined' do
+    it 'does not exclude anything by default' do
+      Notes::Options.default_excludes.should == []
+    end
+
+    it 'uses the current directory by default' do
+      Notes.root.should == Dir.pwd
+    end
+  end
+
+  context 'when Rails is defined' do
+    it 'excludes slow directories by default' do
+      Notes.should_receive(:rails?).and_return(true)
+      Notes::Options.default_excludes.should == %w(tmp log)
+    end
+  end
+end