worked 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,8 @@
+== 0.2.0 2009-06-12
+
+* 1 major enhancement:
+  * Create Gruff Graphs
+
 == 0.1.0 2009-02-19
 
 * 1 major enhancement:

data/Manifest.txt

@@ -7,18 +7,24 @@ bin/worked
 config/website.yml
 lib/worked.rb
 lib/worked/cli.rb
+lib/worked/graph.rb
+lib/worked/inputgrammar.rb
 lib/worked/inputgrammar.treetop
 lib/worked/inputparser.rb
+lib/worked/reader.rb
 lib/worked/recorder.rb
 script/console
 script/destroy
 script/generate
 script/txt2html
+tasks/parser_generate.rake
 tasks/website.rake
 test/test_grammar.rb
 test/test_helper.rb
+test/test_reader.rb
 test/test_worked.rb
 test/test_worked_cli.rb
+website/index.html
 website/javascripts/rounded_corners_lite.inc.js
 website/stylesheets/screen.css
 website/template.rhtml

data/README.rdoc

@@ -1,9 +1,9 @@
 = Worked
 
-The easiest time recording application imagineable.
-
 * http://worked.rubyforge.org/
 
+The easiest time recording application imagineable.
+
 == DESCRIPTION:
 
 Worked is really the simplest time recording (or tracking, whatever term you
@@ -19,6 +19,7 @@ Right now, the times are just recorded, no report generation yet.
 == FEATURES:
 
 * Appends a time range and an activity to a file.
+* Create a graph from the collected data, showing hours/week.
 
 == SYNOPSIS:
 
@@ -57,6 +58,9 @@ write:
 Specifying dates is not supported right now, but you can of course edit the file
 directly if necessary.
 
+Since version 0.2, worked also has the ability to generate a graph from the
+collected data, using the -g argument. [TODO: Add image here.]
+
 == STORY:
 
 The week before my new semester started, I promised to myself to do better (or,

data/Rakefile

@@ -9,6 +9,7 @@ $hoe = Hoe.new('worked', Worked::VERSION) do |p|
   p.rubyforge_name       = p.name
   p.extra_deps         = [
     ['treetop','>= 1.2.4'],
+    ['gruff','>= 0.3.1'],
   ]
   p.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"]

data/bin/worked

@@ -9,6 +9,6 @@ require "worked/cli"
 
 CONFIG = File.join(Dir.getwd, ".worked")
 
-File.open(CONFIG, "a") do |file|
-  Worked::CLI.execute(STDOUT, ARGV.join(" "), file)
+File.open(CONFIG, "a+") do |file|
+  Worked::CLI.execute(STDOUT, ARGV, file)
 end

data/lib/worked.rb

@@ -4,5 +4,5 @@ $:.unshift(File.dirname(__FILE__)) unless
 require 'worked/inputparser'
 
 module Worked
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/worked/cli.rb

@@ -1,37 +1,68 @@
 require 'optparse'
 require 'worked/recorder'
+require 'worked/graph'
 
 module Worked
   class CLI
     def self.execute(stdout, arguments, file)
 
-      Recorder.new(file).record(arguments)
+      if arguments.empty?
+        parse_options(stdout, ["--help"], file)
+      end
 
-      #options = {
-      #  :path     => '~'
-      #}
+      begin
 
-      #parser = OptionParser.new do |opts|
-      #  opts.banner = <<-BANNER.gsub(/^          /,'')
-      #    This application is wonderful because...
+	      try_to_parse(file, arguments.join(" "))
 
-      #    Usage: #{File.basename($0)} [options]
+      rescue CannotParse
 
-      #    Options are:
-      #  BANNER
-      #  opts.separator ""
-      #  opts.on("-p", "--path=PATH", String,
-      #          "This is a sample message.",
-      #          "For multiple lines, add more strings.",
-      #          "Default: ~") { |arg| options[:path] = arg }
-      #  opts.on("-h", "--help",
-      #          "Show this help message.") { stdout.puts opts; exit }
+	      options = parse_options(stdout, arguments, file)
 
-      #  opts.parse!(arguments)
-      #end
+	      if options[:graph_path]
 
-      #path = options[:path]
+	        graph(stdout, file, options[:graph_path])
 
+	      end
+      end
+    end
+
+    def self.try_to_parse file, string
+
+      Recorder.new(file).record(string)
+    end
+
+    def self.graph stdout, file, path
+
+      Graph::create_weekly(Reader::by_week(file.readlines), path)
+
+      stdout.puts "Graph saved to #{path}."
+    end
+
+    def self.parse_options(stdout, arguments, file)
+
+      options = {}
+
+      parser = OptionParser.new do |opts|
+        opts.banner = <<-BANNER.gsub(/^          /,'')
+          This application is wonderful!
+
+          Usage: #{File.basename($0)} [options]
+                 #{File.basename($0)} work time specification
+
+          Options are:
+        BANNER
+        opts.separator ""
+        opts.on("-g", "--graph=PATH", String,
+                "Prints a graph to the specified file.") { |arg|
+                  options[:graph_path] = arg
+                }
+        opts.on("-h", "--help",
+                "Show this help message.") { stdout.puts opts; exit }
+
+        opts.parse!(arguments)
+      end
+
+      options
     end
   end
 end

data/lib/worked/graph.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'gruff'
+
+require 'worked/reader'
+
+module Worked
+
+  class Graph
+
+    def self.create_weekly entries, output_file
+      create(entries, output_file)
+    end
+
+    def self.create_daily entries, output_file
+      create(entries, output_file)
+    end
+
+    private
+
+    def self.create entries, output_file
+
+      g = Gruff::Bar.new
+      g.title = "My Work Hours"
+      g.y_axis_increment = 2
+      g.y_axis_label = "Hours"
+      g.x_axis_label = "Week of the Year"
+
+      g.data("Total: #{entries.sum{|e| e.hours.to_f}.to_i.to_s} Hours", entries.collect {|e| e.hours.to_f})
+
+      g.minimum_value = 0
+
+      g.labels = entries.inject({}) {|h, e|  h.merge( { h.size => e.date.to_s }) }
+
+      g.write output_file
+    end
+  end
+end

data/lib/worked/inputgrammar.rb

@@ -0,0 +1,741 @@
+
+module InputGrammar
+  include Treetop::Runtime
+
+  def root
+    @root || :root
+  end
+
+  module Root0
+    def time
+      elements[0]
+    end
+
+    def activity
+      elements[2]
+    end
+  end
+
+  def _nt_root
+    start_index = index
+    if node_cache[:root].has_key?(index)
+      cached = node_cache[:root][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_time
+    s0 << r1
+    if r1
+      if input.index(" on ", index) == index
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 4))
+        @index += 4
+      else
+        terminal_parse_failure(" on ")
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_activity
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Root0)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:root][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_activity
+    start_index = index
+    if node_cache[:activity].has_key?(index)
+      cached = node_cache[:activity][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if index < input_length
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure("any character")
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+    node_cache[:activity][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_time
+    start_index = index
+    if node_cache[:time].has_key?(index)
+      cached = node_cache[:time][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_time_from
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_time_in_words
+      if r2
+        r0 = r2
+      else
+        r3 = _nt_time_range
+        if r3
+          r0 = r3
+        else
+          r4 = _nt_time_in_digits
+          if r4
+            r0 = r4
+          else
+            self.index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:time][start_index] = r0
+
+    return r0
+  end
+
+  module TimeFrom0
+    def am_pm_time
+      elements[1]
+    end
+  end
+
+  module TimeFrom1
+    def from
+      am_pm_time.to_24h
+    end
+  end
+
+  def _nt_time_from
+    start_index = index
+    if node_cache[:time_from].has_key?(index)
+      cached = node_cache[:time_from][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index("from ", index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 5))
+      @index += 5
+    else
+      terminal_parse_failure("from ")
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_am_pm_time
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TimeFrom0)
+      r0.extend(TimeFrom1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:time_from][start_index] = r0
+
+    return r0
+  end
+
+  module TimeRange0
+    def f
+      elements[0]
+    end
+
+    def t
+      elements[2]
+    end
+  end
+
+  module TimeRange1
+    def from
+      f.to_24h
+    end
+
+    def to
+      t.to_24h
+    end
+  end
+
+  def _nt_time_range
+    start_index = index
+    if node_cache[:time_range].has_key?(index)
+      cached = node_cache[:time_range][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_am_pm_time
+    s0 << r1
+    if r1
+      if input.index(" to ", index) == index
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 4))
+        @index += 4
+      else
+        terminal_parse_failure(" to ")
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_am_pm_time
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TimeRange0)
+      r0.extend(TimeRange1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:time_range][start_index] = r0
+
+    return r0
+  end
+
+  module AmPmTime0
+    def time_in_digits
+      elements[0]
+    end
+
+    def am_pm
+      elements[1]
+    end
+  end
+
+  module AmPmTime1
+    def to_24h
+
+      if methods.include?("am_pm") && am_pm.text_value =~ /pm/
+        return time_in_digits.total + 12.hours
+      end
+
+      time_in_digits.total
+    end
+  end
+
+  def _nt_am_pm_time
+    start_index = index
+    if node_cache[:am_pm_time].has_key?(index)
+      cached = node_cache[:am_pm_time][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_time_in_digits
+    s0 << r1
+    if r1
+      i3 = index
+      if input.index(" am", index) == index
+        r4 = instantiate_node(SyntaxNode,input, index...(index + 3))
+        @index += 3
+      else
+        terminal_parse_failure(" am")
+        r4 = nil
+      end
+      if r4
+        r3 = r4
+      else
+        if input.index(" pm", index) == index
+          r5 = instantiate_node(SyntaxNode,input, index...(index + 3))
+          @index += 3
+        else
+          terminal_parse_failure(" pm")
+          r5 = nil
+        end
+        if r5
+          r3 = r5
+        else
+          if input.index("am", index) == index
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure("am")
+            r6 = nil
+          end
+          if r6
+            r3 = r6
+          else
+            if input.index("pm", index) == index
+              r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
+            else
+              terminal_parse_failure("pm")
+              r7 = nil
+            end
+            if r7
+              r3 = r7
+            else
+              self.index = i3
+              r3 = nil
+            end
+          end
+        end
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AmPmTime0)
+      r0.extend(AmPmTime1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:am_pm_time][start_index] = r0
+
+    return r0
+  end
+
+  module TimeInWords0
+    def minutes
+      elements[1]
+    end
+  end
+
+  module TimeInWords1
+    def hours
+      elements[0]
+    end
+
+    def m
+      elements[1]
+    end
+  end
+
+  module TimeInWords2
+    def total
+	  minutes.to_i.minutes + hours.to_i.hours + m.to_i.minutes
+    end
+  end
+
+  def _nt_time_in_words
+    start_index = index
+    if node_cache[:time_in_words].has_key?(index)
+      cached = node_cache[:time_in_words][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_minutes
+    if r1
+      r0 = r1
+    else
+      i2, s2 = index, []
+      r3 = _nt_hours
+      s2 << r3
+      if r3
+        i5, s5 = index, []
+        if input.index(" ", index) == index
+          r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure(" ")
+          r7 = nil
+        end
+        if r7
+          r6 = r7
+        else
+          r6 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s5 << r6
+        if r6
+          r8 = _nt_minutes
+          s5 << r8
+        end
+        if s5.last
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          r5.extend(TimeInWords0)
+        else
+          self.index = i5
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s2 << r4
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(TimeInWords1)
+        r2.extend(TimeInWords2)
+      else
+        self.index = i2
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        self.index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:time_in_words][start_index] = r0
+
+    return r0
+  end
+
+  module TimeInDigits0
+    def integer
+      elements[1]
+    end
+  end
+
+  module TimeInDigits1
+    def integer
+      elements[0]
+    end
+
+    def m
+      elements[1]
+    end
+  end
+
+  module TimeInDigits2
+    def total
+	  integer.to_i.hours + m.to_i.minutes
+    end
+  end
+
+  def _nt_time_in_digits
+    start_index = index
+    if node_cache[:time_in_digits].has_key?(index)
+      cached = node_cache[:time_in_digits][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_integer
+    s0 << r1
+    if r1
+      i3, s3 = index, []
+      if input.index(":", index) == index
+        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure(":")
+        r4 = nil
+      end
+      s3 << r4
+      if r4
+        r5 = _nt_integer
+        s3 << r5
+      end
+      if s3.last
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        r3.extend(TimeInDigits0)
+      else
+        self.index = i3
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TimeInDigits1)
+      r0.extend(TimeInDigits2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:time_in_digits][start_index] = r0
+
+    return r0
+  end
+
+  module Hours0
+  end
+
+  module Hours1
+    def integer
+      elements[0]
+    end
+
+  end
+
+  def _nt_hours
+    start_index = index
+    if node_cache[:hours].has_key?(index)
+      cached = node_cache[:hours][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_integer
+    s0 << r1
+    if r1
+      if input.index(" ", index) == index
+        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure(" ")
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+      if r2
+        i4 = index
+        i5, s5 = index, []
+        if input.index("hour", index) == index
+          r6 = instantiate_node(SyntaxNode,input, index...(index + 4))
+          @index += 4
+        else
+          terminal_parse_failure("hour")
+          r6 = nil
+        end
+        s5 << r6
+        if r6
+          if input.index("s", index) == index
+            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("s")
+            r8 = nil
+          end
+          if r8
+            r7 = r8
+          else
+            r7 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s5 << r7
+        end
+        if s5.last
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          r5.extend(Hours0)
+        else
+          self.index = i5
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          if input.index("h", index) == index
+            r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("h")
+            r9 = nil
+          end
+          if r9
+            r4 = r9
+          else
+            self.index = i4
+            r4 = nil
+          end
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Hours1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:hours][start_index] = r0
+
+    return r0
+  end
+
+  module Minutes0
+  end
+
+  module Minutes1
+    def integer
+      elements[0]
+    end
+
+  end
+
+  module Minutes2
+    def total
+      integer.to_i.minutes
+    end
+  end
+
+  def _nt_minutes
+    start_index = index
+    if node_cache[:minutes].has_key?(index)
+      cached = node_cache[:minutes][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_integer
+    s0 << r1
+    if r1
+      if input.index(" ", index) == index
+        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure(" ")
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+      if r2
+        i4 = index
+        i5, s5 = index, []
+        if input.index("minute", index) == index
+          r6 = instantiate_node(SyntaxNode,input, index...(index + 6))
+          @index += 6
+        else
+          terminal_parse_failure("minute")
+          r6 = nil
+        end
+        s5 << r6
+        if r6
+          if input.index("s", index) == index
+            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("s")
+            r8 = nil
+          end
+          if r8
+            r7 = r8
+          else
+            r7 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s5 << r7
+        end
+        if s5.last
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          r5.extend(Minutes0)
+        else
+          self.index = i5
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          if input.index("m", index) == index
+            r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("m")
+            r9 = nil
+          end
+          if r9
+            r4 = r9
+          else
+            self.index = i4
+            r4 = nil
+          end
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Minutes1)
+      r0.extend(Minutes2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:minutes][start_index] = r0
+
+    return r0
+  end
+
+  def _nt_integer
+    start_index = index
+    if node_cache[:integer].has_key?(index)
+      cached = node_cache[:integer][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if input.index(Regexp.new('[0-9]'), index) == index
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+    node_cache[:integer][start_index] = r0
+
+    return r0
+  end
+
+end
+
+class InputGrammarParser < Treetop::Runtime::CompiledParser
+  include InputGrammar
+end
+