todonotes 0.1.0

data/examples/todonotes_how_to.rb

@@ -0,0 +1,38 @@
+$:.unshift('../lib')
+require 'todonotes'
+
+to do 
+  "mein Ergebnis"
+end
+
+todo "mein Text"
+
+todo { "mein Ergebnis" }
+
+todo ('mein Text' ) { "mein Ergebnis" }
+
+todo do
+  "mein Ergebnis"
+end
+
+todo 'Text' do
+  "mein Ergebnis"
+end
+
+####################
+2.times { fixme "mein Text" }
+
+fixme { "mein Ergebnis" }
+
+fixme ('mein Text' ) { "mein Ergebnis" }
+
+fixme do
+  "mein Ergebnis"
+end
+
+fixme 'Text' do
+  "mein Ergebnis"
+end
+####################
+
+Todonotes.print_stats

data/examples/todonotes_prim.rb

@@ -0,0 +1,25 @@
+$:.unshift('../lib')
+require 'todonotes'
+
+#
+#
+Todonotes.instance.logger.level = Log4r::WARN #only first time of callinf a fixme/todo
+Todonotes.instance.logger.level = Log4r::INFO   #report all calls of fixme/todo
+
+primecount = 0
+for i in 1..10
+        if fixme "Calculate if prime" do 
+              i.odd?  #tempory: odd = prim
+            end
+          primecount += 1 
+          puts "#{i} is a prime number"
+        else
+          puts "#{i} is no prime number"
+        end
+end
+
+todo "Return total number of primes"
+
+#Details
+Todonotes.print_stats()
+

data/examples/todonotes_prim2.rb

@@ -0,0 +1,32 @@
+$:.unshift('../lib')
+require 'todonotes'
+
+#
+#
+Todonotes.instance.logger.level = Log4r::WARN #only first time of callinf a fixme/todo
+Todonotes.instance.logger.level = Log4r::INFO   #report all calls of fixme/todo
+
+class Fixnum
+  def prime?
+      fixme "Calculate if prime" do 
+              self.odd?  #tempory: odd = prim
+      end    
+  end
+end
+
+primecount = 0
+for i in 1..10
+        if i.prime?
+          primecount += 1 
+          puts "#{i} is a prime number"
+        else
+          puts "#{i} is no prime number"
+        end
+end
+
+todo "Return total number of primes"
+
+#Details
+Todonotes.print_stats()
+
+

data/lib/todonotes.rb

@@ -0,0 +1,211 @@
+=begin rdoc
+Define todo- and fixme-command.
+
+Usage:
+Add todo and fixme to your code and get track of your todos during 
+runtime of your code.
+
+When you pass a todo/fixme during execution, you get a logging information.
+
+
+  todo ('message' ) { "temporary result" }
+  fixme ('message' ) { "temporary result" }
+
+todo and fixme have the same syntax, the sematic meaning is:
+* ToDo: Mark missing code.
+* FixMe: Mark code to repair.
+
+Disadvantage:
+* Does not replace a good IDE. 
+  to see the ToDo/FixMe 
+
+Gem based on a proposal in http://forum.ruby-portal.de/viewtopic.php?f=11&t=11957
+
+=end
+
+require 'singleton'
+require 'log4r'
+
+=begin rdoc
+Define a formatter.
+=end
+class Log4r::FixmeFormatter < Log4r::BasicFormatter
+=begin rdoc
+If event is an Array, the output is adapted.
+
+This outputter is only for internal use via Todonotes.
+=end
+    def format(event)
+      #@@basicformat      "%*s %s"
+      #~ buff = sprintf("%-*s %-5s", Log4r::MaxLevelLength, Log4r::LNAMES[event.level],
+             #~ event.data.is_a?(Array) ? event.data.first : event.name)
+      buff = "%-5s" % (event.data.is_a?(Array) ? event.data.first : event.name)
+      #~ buff += (event.tracer.nil? ? "" : "(#{event.tracer[2]})") + ": "
+      buff << ": "
+      buff << format_object(event.data.is_a?(Array) ? event.data.last : event.data) 
+      buff << (event.tracer.nil? ? "" : " (#{event.tracer.join('/')})")
+      buff << "\n"
+      buff
+    end
+end
+
+=begin rdoc
+Singleton definition for a fixme.
+
+You can use Fixme#instance to set some global settings:
+* FiXme#log2file Define log file
+* FiXme#logger adapt level, outputter ...
+* FiXme#codeline get Hash with counter per ToDo-locations.
+* FiXme#overview get overview text with ToDo-locations.
+=end
+class Todonotes
+  VERSION = '0.1.0'
+  include Singleton
+=begin rdoc
+Define the singleton-instance.
+=end
+  def initialize()
+    # @codeline is a Hash with Filename and codeline (key). Value is the number of calls.
+    @codeline = Hash.new(0)
+    @logger = Log4r::Logger.new('ToDo')
+    @logger.outputters = Log4r::StdoutOutputter.new('ToDo', 
+                                    :level => Log4r::ALL,
+                                    :formatter => Log4r::FixmeFormatter 
+                                  )
+    #~ @logger.trace = true
+  end
+  #Get logger to define alternative outputters...
+  attr_reader :logger
+=begin rdoc
+Write the todo's in a logging file.
+
+Default filename is $0.todo
+=end
+  def log2file(filename = File.basename($0) + '.todo', level = Log4r::ALL)
+    @logger.add( Log4r::FileOutputter.new('ToDo', 
+                                    :filename => filename,
+                                    :level => level,
+                                    :formatter => Log4r::FixmeFormatter 
+                                  ))
+    
+  end
+  #Direct access to the codeline list. See also #todo_overview
+  attr_reader :codeline
+=begin rdoc
+Report a FixMe or a ToDo.
+
+The comment is logged, 
+the block is evaluated to get a temporary result.
+=end
+  def todo( comment, type = :ToDo, &block)
+    res = nil
+    key = caller[1].split(':in').first
+    if block_given?
+      res = yield self
+      res
+    end
+    log_todo(key, type, comment, res)
+    #~ @logger.debug("Return #{res.inspect} instead") if @logger.debug?
+    res
+  end
+=begin rdoc
+Report the ToDo/FixMe and count occurence.
+
+The first occurence is reported as a warning, 
+next occurences are informations.
+=end
+  def log_todo( key, type, text, res )
+
+    @codeline[key] += 1
+    if @codeline[key] == 1 #First occurence?
+      @logger.warn([type, "#{key} #{text} (temporary: #{res.inspect})"])
+    else  #Erste auftauchen
+      @logger.info([type, "#{key}(#{@codeline[key]}) #{text} (temporary: #{res.inspect})"])
+    end
+    
+  end
+  
+=begin rdoc
+Return a text to be printed
+  puts Todonotes.instance.todo_overview()
+Used from Todonotes.print_stats
+
+Example:
+  List of ToDos/FixMes:
+  fixme.rb:195:    1 call
+  fixme.rb:198:    2 calls
+  fixme.rb:199:    1 call
+  fixme.rb:200:    1 call
+=end
+  def overview( )
+    txt = []
+    txt << "List of ToDos/FixMes:"
+    @codeline.each do |key, messages|
+      txt << "%s: %4i call%s" % [ key, messages, messages > 1 ? 's': ''  ]
+    end
+    txt.join("\n")
+  end
+
+=begin rdoc
+Class methods
+=end
+  class << self
+=begin rdoc
+See Todonotes#overview
+=end
+    def print_stats()
+      puts Todonotes.instance.overview()
+    end
+  end #<< self
+end
+
+=begin rdoc
+Define todo-commands to global usage.
+=end
+module Kernel
+=begin rdoc
+Usage 1 (only message):
+  todo "my todo-message""
+
+Usage 2 (only temporary result):
+  todo { "temporary result" }
+  todo do
+    "temporary result"
+  end
+
+Usage 3(message and temporary result):
+  todo ('message') { "temporary  result" }
+  todo ('message') do
+    "temporary result"
+  end
+
+=end
+  def todo( comment = 'ToDo', &block)
+    Todonotes.instance.todo(comment, &block)
+  end
+=begin rdoc
+Usage:
+  to do 
+    :result
+  end
+=end
+  alias :to :todo
+=begin rdoc
+Add a fixme-command.
+
+Can be used to mark available code.
+=end
+  def fixme( comment = 'FixMe', &block)
+    Todonotes.instance.todo(comment, :FixMe, &block)
+  end  
+end
+
+if $0 == __FILE__
+  todo( 'a' ){  
+    "result" 
+  }
+  2.times{todo { "result" }}
+  fixme { "result" }
+  to('a') 
+  Todonotes.print_stats( )
+end

data/readme.rd

@@ -0,0 +1,110 @@
+=fixme
+Define todo- and fixme-command.
+
+==Usage:
+Add todo and fixme to your code and get track of your todos during 
+runtime of your code.
+
+When you pass a todo/fixme during execution, you get a logging information.
+
+  todo ('message' ) { "temporary result" }
+  fixme ('message' ) { "temporary result" }
+
+todo and fixme have the same syntax, the sematic meaning is:
+* ToDo: Mark missing code.
+* Todonotes: Mark code to repair.
+
+Disadvantage:
+* Does not replace a good IDE. 
+  to see the ToDo/Todonotes 
+
+Gem based on a proposal in http://forum.ruby-portal.de/viewtopic.php?f=11&t=11957
+
+=Example
+
+Think, you have to write a script to count all prime between 1 to 10.
+
+You don't know how to check for primes, but at least you know,  primes must be odd.
+
+So you can start your program:
+  require 'todonotes'
+
+  primecount = 0
+  for i in 1..10
+          if fixme "Calculate if prime, prim = true, ja, sonst nein" do 
+                i.odd?  #tempory: odd = prim
+              end
+            primecount += 1 
+            puts "#{i} is a prime number"
+          else
+            puts "#{i} is no prime number"
+          end
+  end
+
+  todo "Return total number of primes"
+
+Or
+  require 'todonotes'
+  class Fixnum
+    def prime?
+        fixme "Calculate if prime" do 
+                self.odd?  #tempory: odd = prim
+        end    
+    end
+  end
+
+  primecount = 0
+  for i in 1..10
+          if i.prime?
+            primecount += 1 
+            puts "#{i} is a prime number"
+          else
+            puts "#{i} is no prime number"
+          end
+  end
+
+  todo "Return total number of primes"
+
+Now you get a output like this:
+
+  Todonotes: todonotes_prim2.rb:12 Calculate if prime misssing (temporary: true)
+  1 is a prime number
+  Todonotes: todonotes_prim2.rb:12(2) Calculate if prime misssing (temporary: false)
+  2 is no prime number
+  Todonotes: todonotes_prim2.rb:12(3) Calculate if prime misssing (temporary: true)
+  ...
+  ToDo : todonotes_prim2.rb:27 Return total number of primes (temporary: nil)
+
+
+The Todonotes is warning about a wrong or uncompleted code piece.
+
+The ToDo is warning for a missing code piece.
+
+You are informed about source code file and line number. In braces you get the number of calls.
+
+The todo/fixme command evaluates the optional block.
+The result is returned as a temporary result (in this example: odd numbers are primes.).
+
+==Logging
+
+The Fixme and ToDo are reported via a logger.
+The first call of a fixme/todo is a warning, the next call is an information.
+
+
+You may change the level with:
+  Todonotes.instance.logger.level = Log4r::WARN #only first time of callinf a fixme/todo
+  Todonotes.instance.logger.level = Log4r::INFO   #report all calls of fixme/todo
+
+You can log the fixme/todos to a file:
+  Todonotes.instance.log2file()
+
+==Get Overview
+You may print an overview on all fixme/todos:
+  Todonotes.print_stats()
+
+Example:
+  List of ToDos/Todonotess:
+  todonotes_prim.rb:11:   10 calls
+  todonotes_prim.rb:21:    1 call
+
+There is a fixme/todo in line 11 and 21 in todonotes_prim.rb.

data/unittest/unittest_todonotes.rb

@@ -0,0 +1,177 @@
+gem 'test-unit'
+require 'test/unit'
+
+$:.unshift('../lib')
+require 'todonotes'
+
+=begin rdoc
+Define a new outputter to catch data into an array
+=end
+class ArrayOutputter < Log4r::StdoutOutputter
+=begin rdoc
+Collect messages in array.
+=end
+  def write(message)
+    @messages ||= []  #create with first call
+    @messages  << message
+  end
+=begin rdoc
+Clear message array and return messages
+=end
+  def flush
+    @messages ||= []  #create with first call
+    messages = @messages.dup
+    @messages.clear
+    messages
+  end
+end #ArrayOutputter
+
+#~ Todonotes.instance.logger.level = Log4r::OFF  #No logging
+Todonotes.instance.logger.outputters.first.level = Log4r::OFF
+Todonotes.instance.logger.outputters << $testlog = ArrayOutputter.new('testlog')
+$testlog.formatter = Log4r::FixmeFormatter.new
+
+class Test_syntax < Test::Unit::TestCase
+  def test_todo()
+    assert_nothing_raised{
+      to do 
+        "mein Ergebnis"
+      end
+    }
+    assert_nothing_raised{
+      todo "mein Text"
+    }
+    assert_nothing_raised{
+      todo { "mein Ergebnis" }
+    }
+    assert_nothing_raised{
+      todo ('mein Text' ) { "mein Ergebnis" }
+    }
+    assert_nothing_raised{
+      todo do
+        "mein Ergebnis"
+      end
+    }
+    assert_nothing_raised{
+      todo 'Text' do
+        "mein Ergebnis"
+      end    
+    }
+  end
+  def test_fixme
+    assert_nothing_raised{
+      fixme "mein Text"
+    }
+    assert_nothing_raised{
+      fixme { "mein Ergebnis" }
+    }
+    assert_nothing_raised{
+      fixme ('mein Text' ) { "mein Ergebnis" }
+    }
+    assert_nothing_raised{
+      fixme do
+        "mein Ergebnis"
+      end
+    }
+    assert_nothing_raised{
+      fixme 'Text' do
+        "mein Ergebnis"
+      end    
+    }
+  end
+  #~ def test_print_stats
+    #~ assert_nothing_raised{ print_stats }
+  #~ end  
+end
+
+class Test_value_and_log < Test::Unit::TestCase
+  def setup()
+    $testlog.flush
+  end
+  
+  def test_todo()
+    assert_equal("mein Ergebnis", todo() { "mein Ergebnis" } )
+    assert_equal(["ToDo : #{__FILE__}:#{__LINE__ - 1} ToDo (temporary: \"mein Ergebnis\")\n"], $testlog.flush )
+    
+    assert_equal("mein Ergebnis", todo( 'text' ){"mein Ergebnis"} )
+    assert_equal(["ToDo : #{__FILE__}:#{__LINE__ - 1} text (temporary: \"mein Ergebnis\")\n"], $testlog.flush )
+    
+    assert_equal(nil, todo( "my text"))
+    assert_equal(["ToDo : #{__FILE__}:#{__LINE__ - 1} my text (temporary: nil)\n"], $testlog.flush )
+        
+  end
+  def test_fixme
+    assert_equal("mein Ergebnis", fixme() {"mein Ergebnis"} )
+    assert_equal(["FixMe: #{__FILE__}:#{__LINE__ - 1} FixMe (temporary: \"mein Ergebnis\")\n"], $testlog.flush )
+    
+    assert_equal("mein Ergebnis", fixme( 'text' ){"mein Ergebnis"} )
+    assert_equal(["FixMe: #{__FILE__}:#{__LINE__ - 1} text (temporary: \"mein Ergebnis\")\n"], $testlog.flush )
+    
+    assert_equal(nil, fixme( "my text"))
+    assert_equal(["FixMe: #{__FILE__}:#{__LINE__ - 1} my text (temporary: nil)\n"], $testlog.flush )
+  end
+end
+
+class Test_overview < Test::Unit::TestCase
+  def test_overview()
+    Todonotes.instance.codeline.clear
+    
+    #check empty fixme/todo
+    text = "List of ToDos/FixMes:"
+    codeline = {}
+    assert_equal(text, Todonotes.instance.overview())
+    assert_equal(codeline, Todonotes.instance.codeline)
+    
+    line = __LINE__; fixme('a')
+    text << "\n#{__FILE__}:#{line}:    1 call"
+    codeline["#{__FILE__}:#{line}"] = 1
+    assert_equal(text, Todonotes.instance.overview())
+    assert_equal(codeline, Todonotes.instance.codeline)
+    
+    #Add 2nd todo
+    line = __LINE__; fixme('b')
+    text << "\n#{__FILE__}:#{line}:    1 call"
+    codeline["#{__FILE__}:#{line}"] = 1
+    assert_equal(text, Todonotes.instance.overview())
+    assert_equal(codeline, Todonotes.instance.codeline)
+    
+    #check plural-s in calls
+    line = __LINE__; 2.times{ fixme('c') }
+    text << "\n#{__FILE__}:#{line}:    2 calls"
+    codeline["#{__FILE__}:#{line}"] = 2
+    assert_equal(text, Todonotes.instance.overview())
+    assert_equal(codeline, Todonotes.instance.codeline)
+  end
+end
+
+class Test_log_with_file < Test::Unit::TestCase
+  @@logfilename = 'test.log'
+  @@logfilename_default = File.basename($0) + '.todo'
+  def setup()
+    File.delete(@@logfilename) if File.exist?(@@logfilename)
+    File.delete(@@logfilename_default) if File.exist?(@@logfilename_default)
+  end
+  def teardown()
+    File.delete(@@logfilename) if File.exist?(@@logfilename)
+    File.delete(@@logfilename_default) if File.exist?(@@logfilename_default)
+  end
+  def test_logfile()
+    assert_false(File.exist?(@@logfilename))
+    Todonotes.instance.log2file(@@logfilename)
+    assert_equal(@@logfilename, Todonotes.instance.logger.outputters.last.filename)
+    assert_true(File.exist?(@@logfilename))
+    Todonotes.instance.logger.outputters.last.close #
+    Todonotes.instance.logger.outputters.pop  #
+  end
+  def test_logfile_default()
+    assert_false(File.exist?(@@logfilename_default))
+    Todonotes.instance.log2file() #no filename
+    assert_equal(@@logfilename_default, Todonotes.instance.logger.outputters.last.filename)
+    assert_true(File.exist?(@@logfilename_default))
+    Todonotes.instance.logger.outputters.last.close #
+    Todonotes.instance.logger.outputters.pop  #
+  end
+end
+
+
+__END__

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: todonotes
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Knut Lickert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-24 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: |
+  todonotes.
+  Support programming by fixme/todo commands
+  
+  Gem based on a proposal in http://forum.ruby-portal.de/viewtopic.php?f=11&t=11957
+
+email: knut@lickert.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- readme.rd
+files: 
+- readme.rd
+- lib/todonotes.rb
+- examples/todonotes_how_to.rb
+- examples/todonotes_prim.rb
+- examples/todonotes_prim2.rb
+- unittest/unittest_todonotes.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- readme.rd
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Support programming by todonotes/todo commands.
+test_files: 
+- unittest/unittest_todonotes.rb