cronedit 0.2.0 → 0.3.0

data/lib/cronedit.rb

@@ -3,9 +3,15 @@
 # 
 # Allows to manipulate crontab from comfortably from ruby code. 
 # You can add/modify/remove (aka CRUD) named crontab entries individually with no effect on the rest of your crontab.
-# You can define cron entry definitions as standart text definitions <tt>'10 * * * * echo 42'</tt> or using Hash notation <tt>{:minute=>10, :command=>'echo 42'}</tt> (see CronEntry ::DEFAULTS)
-# Additionaly you can parse cron text definitions to Hash.
+# You can define cron entry definitions as standard text definitions <tt>'10 * * * * echo 42'</tt> or using Hash notation <tt>{:minute=>10, :command=>'echo 42'}</tt> (see CronEntry ::DEFAULTS)
+# Additionally you can parse cron text definitions to Hash. 
+#
+# From other features: CronEdit allows you to make bulk updates of crontab; the same way you manipulate live crontab you can edit file or in-memory definitions and combine them arbitrarily. 
 # 
+# ==Install
+# * Available as gem: <tt>gem install cronedit</tt>
+# * Project development page, downloads, forum, svn: http://rubyforge.org/projects/cronedit/
+#
 # ==Usage
 # 
 # Class methods offer quick crontab operations. Three examples:
@@ -13,55 +19,88 @@
 #       CronEdit::Crontab.Add  'agent2', {:minute=>5, :command=>'echo 42'}
 #       CronEdit::Crontab.Remove 'someId'
 # 
-# or define a batch update and list the current content: 
+# Define a batch update and list the current content: 
 # 
-#       cm = CronEdit:Crontab.new 'user'
+#       cm = CronEdit::Crontab.new 'user'
 #       cm.add 'agent1', '5,35 0-23/2 * * * echo agent1'
 #       ...
 #       cm.add 'agent2', {:minute=>5, :command=>'echo 42'}
 #       cm.commit
 #       p cm.list
+#
+# see CronEdit::Crontab class for all available methods
+#
+# You can do a bulk merge (or removal) of definitions from a file using CronEdit::FileCrontab
+#       fc = FileCrontab.new 'example1.cron'
+#       Crontab.Merge fc
+#       p Crontab.List
+#       Crontab.Subtract fc
+#
+# Similary to CronEdit::FileCrontab you can you also CronEdit::DummyCrontab for in-memory crontabs.
+# Above all, you can combine all three crontab implementations Crontab, FileCrontab, DummyCrontab arbitrarily.
+#
+# see <tt>test/examples/examples.rb</tt> for more examples !
 #       
-# see Crontab for all available methods
 # ==Author
-# Viktor Zigo, http://7inf.com, All rights reserved. You can redistribute it and/or modify it under the same terms as Ruby.
-# (parts of the  cron definition parsing code originaly by gotoken@notwork.org)
+# Viktor Zigo, http://alephzarro.com, All rights reserved. You can redistribute it and/or modify it under the same terms as Ruby.
+# (parts of the  cronentry definition parsing code originally by gotoken@notwork.org)
+#
+# Sponsored by: http://7inf.com
 # ==History
-# version: 0.2.0 
+# * version: 0.3.0  2008-02-02
+# ** keeps/survives full fromatting; FileCrontab; DummyCrontab; bulk addition and removal; clear crontab; more testcases; examples; and other
+# * version: 0.2.0 
 #
 # ==TODO
-# add more commands (clean crontab); lift some methods to class; put tests to separate file; make rake, make gem; implement addAllfrom
-# add Utils: getNext execution
+# * add Utils: getNext execution
+# * platform specific options (headers; vixiecron vs. dilloncron) 
 module CronEdit
-    self::VERSION = '0.2.0' unless defined? self::VERSION
-        
+    self::VERSION = '0.3.0' unless defined? self::VERSION
+    
+    # Main class that manipulates actual system cron. Additionally, it is the base class for other types of Crontab utils (FileCrontab, DummyCrontab)
     class Crontab
         # Use crontab for user aUser
         def initialize aUser = nil
             @user = aUser
+            @opts = {:close_input=>true, :close_output=>true}
             rollback()
         end
 
         class <<self
-            # Add a new crontab entry definition. See instance add method
+            # Add a new crontab entry definition. (see instance method add).
             def Add anId, aDef
-                cm = Crontab.new
+                cm = self.new
                 entry = cm.add anId, aDef
                 cm.commit
                 entry
             end
         
-            # Remove a crontab entry definition identified by anId from current crontab.
-            def Remove anId
-                cm = Crontab.new
-                cm.remove anId
+            #  Remove a crontab entry definitions identified by anIds from current crontab (see instance method remove).
+            def Remove *anIds
+                cm = self.new
+                cm.remove *anIds
                 cm.commit
             end
         
             # List current crontab.
             def List
-                Crontab.new.list
-            end
+                self.new.list
+            end        
+        
+            #Merges this crontab with another one (see instance method merge).
+            def Merge anotherCrontab
+                cm=self.new
+                cm.merge anotherCrontab
+                cm.commit
+            end         
+        
+            #Removes crontab definitions of another crontab (see instance method subtract).
+            def Subtract anotherCrontab
+                cm=self.new
+                cm.subtract anotherCrontab
+                cm.commit
+            end         
+        
         end
     
         # Add a new crontab entry definition. Becomes effective only after commit().
@@ -70,51 +109,75 @@ module CronEdit
         # returns newly added CronEntry
         def add anId, aDef
             @adds[anId.to_s] = CronEntry.new( aDef )
+            @removals.delete anId.to_s
         end
 
-        # Bulk addition of  crontab entry definitions from stream (String, File, IO)
-        def addAllFrom anIO
-            #TODO: load file, parse it 
-            raise 'Not implemented yet'
+        # Bulk addition/merging of  crontab definitions from another Crontab (FileCrontab, DummyCrontab, or a Crontab of another user)
+        def merge aCrontab
+            entries, lines = aCrontab.listFull
+            #todo: we throw the incoming lines away
+            #merge original data
+            @adds.merge! entries
+            #merge noncommited data as well
+            aCrontab.adds.each {|k,v| @adds[k]=v}
+            aCrontab.removals.each {|k,v| remove k}
+            self
         end 
     
-        # Remove a crontab entry definition identified by anId. Becomes effective only after commit().
-        def remove anId
-            @adds.delete anId.to_s
-            @removals[anId.to_s]=anId.to_s
+        # Bulk subtraction/removal of crontab definitions from another Crontab (FileCrontab, DummyCrontab, or a Crontab of another user)
+        def subtract aCrontab
+            entries, lines = aCrontab.listFull
+            entries.each {|id,entry| remove id}
+            aCrontab.adds.each {|id,entry| remove id}
         end
     
+        # Remove a crontab entry definitions identified by anIds. Becomes effective only after commit().
+        def remove *anIds
+            anIds.each { |id|
+                @adds.delete id.to_s
+                @removals[id.to_s]=id.to_s
+            }
+        end
+        
         # Merges the existing crontab with all modifications and installs the new crontab.
         # returns the merged parsed crontab hash
         def commit
             # merge crontab
-            current = list()
-            current.delete_if {|id, entry| @removals.include? id}
-            merged = current.merge @adds
-        
+            currentEntries, lines = listFull()
+            mergedEntries = nil
             # install it
-            cmd = @user ? "crontab -u #{@user} -" : "crontab -"
-            IO.popen(cmd,'w') {|io|
-                merged.each {|id, entry|
-                    io.puts "# #{id}"
-                    io.puts entry
-                }
-                io.close
-            }
+            io = getOutput
+            begin
+                mergedEntries = dumpCron currentEntries, lines, io
+            ensure
+                io.close if @opts[:close_output]
+            end
             # No idea why but without this any wait crontab reads and writes appears not synchronizes
             sleep 0.01
             #clean changes :)
             rollback()
-            merged
+            mergedEntries
         end
-    
+        
         # Discards all modifications (since last commit, or creation)
         def rollback
             @adds = {}
             @removals = {}
         end
     
-        # Prints out the items to be added and removed
+        # Clear crontab completely and immediately. Warning: no commit needed (no rollback anymore)
+        def clear!
+            rollback
+            # we dont do it using crontab command  (-r , -d) because it differs on various platfoms (vixiecron vs. dilloncron)
+            io = getOutput
+            begin
+                io << ''
+            ensure
+                io.close if @opts[:close_output]
+            end
+        end
+    
+        # A helper method that prints out the items to be added and removed
         def review
             puts "To be added: #{@adds.inspect}"
             puts "To be removed: #{@removals.keys.inspect}"
@@ -123,43 +186,225 @@ module CronEdit
         # Read the current crontab and parse it
         # returns a Hash (entry id or index)=>CronEntry
         def list
-            cmd = @user ? "crontab -u #{@user} -l" : "crontab -l"
-            IO.popen(cmd) {|io|
-                return parseCrontab(io)
-            }
+            res = listFull
+            res ? res[0] : nil
         end
 
+        # Read the current crontab and parse it, keeping the format
+        # returns a [entires, lines]  where entries = Hash (entry id or index)=>CronEntry; lines = Array of Strings of EntryPlaceholders
+        def listFull
+            io = getInput
+            begin
+                return parseCrontabFull(io)
+            ensure
+                io.close if @opts[:close_input]
+            end
+        end
+    
         # Lists raw content from crontab
         # returns array of text lines
         def listRaw
-            cmd = @user ? "crontab -u #{@user} -l" : "crontab -l"
-            IO.popen(cmd) {|io|
-                    entries = io.readlines
-                    return (entries.first =~ /^no/).nil? ? entries : []
-            }
+            io = getInput
+            begin
+                entries = io.readlines
+                return (entries.first =~ /^no/).nil? ? entries : []   #returns empty list if no entry
+            ensure
+                io.close if @opts[:close_input]
+            end
         end    
-
+    
+        #Set alternative I/O for reading/writing cron entries. If set, the respective stream will be used instead of calling system 'crontab'
+        def setIO anInput, anOutput
+            @input = anInput
+            @output = anOutput
+            self
+        end
+    protected
+        # Parses cron definition from a stream
+        # returns Hash of id->CrontEntries
         def parseCrontab anIO
+            res = parseCrontabFull(anIO)
+            res ? res[0] : nil
+        end
+    
+        # Parses cron definition from a stream
+        # returns [hash of CronEntries, Array of all lines (and placeholders)]
+        def parseCrontabFull anIO
+                lines=[]
                 entries = {}
                 idx = 0
                 id = nil
                 anIO.each_line { |l|
                     l.strip!
+                    lines << l if l.empty? #  keep empty lines           and opts[:keepformat]
                     next if l.empty?
-                    return {} unless (l =~ /^no/).nil?
-                    if l=~/^#/ 
-                        id = l[1, l.size-1].strip
-                    else 
-                        key = id.nil? ? (idx+=1) : id
+                    return [entries, lines] unless (l =~ /^no crontab/).nil? # if crontab contains no schedule it returns 'no crontab for ...'
+        
+                    if l=~/^#/    #is it comment or ID ?
+                        id = EntryPlaceholder.Create l
+                        lines << l unless id #add the raw line to the lines if no id
+                    elsif not (l =~ /^\w+\ *=/).nil?  # is it variable definition ?
+                        lines << l
+                        id = nil
+                    else # it should be cron entry definition
+                        id = EntryPlaceholder.new(idx+=1) unless id # if there is no id generate an anonymous id
+                        lines << id #add placeholder to lines
+                        key = id.id  
                         entries[key.to_s]=l
                         id = nil
                     end
                 }
-                entries
+                [entries, lines]
         end    
+
+    private
+        def dumpCron anEntries, aLines, anIO
+            currentEntries=anEntries.clone
+            currentEntries.delete_if {|id, entry| @removals.include? id}
+            mergedEntries = currentEntries.merge @adds
+       
+            usedIds=[]
+            # dump lines and placeholders
+            aLines.each { |line|
+                if line.respond_to? :mergedump
+                    usedIds << line.mergedump( anIO, mergedEntries )
+                else
+                    anIO.puts line.to_s
+                end
+            }
+            #dump new entries
+            restIds  = mergedEntries.keys - usedIds
+            restLines = restIds.map {|id| EntryPlaceholder.new id}
+            restLines .each {|line| line.mergedump anIO, mergedEntries }
+            mergedEntries
+        end
+
+    protected
+        # override this if you want to get the cron definition from other sources
+        def getInput
+            if @input
+                @input
+            else 
+                cmd = @user ? "crontab -u #{@user} -l" : "crontab -l"
+                IO.popen(cmd)
+            end        
+        end
+
+        # override this if you want to write the cron definition from other destination
+        def getOutput
+            if @output
+                @output
+            else 
+                cmd = @user ? "crontab -u #{@user} -" : "crontab -"
+                IO.popen(cmd,'w')
+            end
+        end
+    
+        attr_reader :adds, :removals
     end 
 
+    # FileCrontab allows you to read in/write out crontab definitions from/to files. You might want to use it for merging some enire file to crontab.
+    # If '-' is given instead of  input file / output file the definitions are streamed from/into STDIN/STDOUT. 
+    #
+    # Example:
+    #       fc = FileCrontab.new 'crontemplate.txt', '/tmp/crontest.txt'
+    #       fc.add 'agent', '59 * * * * echo "modified"'
+    #       fc.remove 'agent2'
+    #       fc.commit
+    #
+    # or create a crontab fron scratch and output to STDOUT
+    #       fc = FileCrontab.new nil, '-'
+    #       fc.add 'agent', '59 * * * * echo "modified"'
+    #       fc.commit
+
+
+    class FileCrontab < Crontab 
+        # anInputFile and anOutputFile can be either filename - to r/w the file, '-' to use STDIN/STDOUT, or nil for no input/output
+        def initialize anInputFile = nil, anOutputFile = nil
+            super nil
+            @input = anInputFile
+            @opts[:close_input] = false if @input=='-'
+            @output = anOutputFile
+            @opts[:close_output] = false if @output=='-'
+        end
+    protected
+        def getInput
+            case @input
+                when nil then StringIO.new
+                when '-' then STDIN
+                else File.open( @input, 'r' ) 
+            end
+        end
+
+        def getOutput
+            case @output
+                when nil then StringIO.new
+                when '-' then STDOUT
+                else File.open( @output, 'w' ) 
+            end
+        end    
+    end
+    
+    # DummyCrontab allows you to create crontab definitions from scratch and dump them out as string. (Or combine them with other Crontab definitions)
+    #
+    # Example:
+    #       fc = DummyCrontab.new
+    #       fc.add 'agent1', '59 * * * * echo "agent1"'
+    #       fc.add 'agent2', {:hour=>'2',:command=>'echo "huh"'}
+    #       fc.commit
+    #       puts fc
+    class DummyCrontab < Crontab 
+        require 'stringio'
+        def initialize
+            super nil
+            @buffer = StringIO.new
+        end
+    
+        def to_s
+            @buffer.string
+        end
+    
+    protected
+        def getInput
+            #loopback - for multiple use
+            StringIO.new @buffer.string
+        end
+
+        def getOutput
+            @buffer = StringIO.new
+        end    
+    end
+    # When the Crontab object reads in (parse) all lines, placeholder appears where a Crontab entry with an id was detected
+    class EntryPlaceholder
+        attr_reader :id
+        def self.Create(aLine)
+            id = ScanId aLine
+            return id ? EntryPlaceholder.new(id) : nil
+        end
+        def self.ScanId aStr
+            aStr.scan(/^\#\#__(.*)__/).flatten.first
+        end
+        def self.GenerateId anId
+            "##__#{anId}__"
+        end    
+        def initialize anId
+            @id = anId.to_s
+        end
+    
+        #returns used id
+        def mergedump anIO, anEntryHash
+            entry = anEntryHash[@id]
+            if entry
+                anIO.puts "#{EntryPlaceholder.GenerateId @id}\n"
+                anIO.puts "#{entry}\n"
+                return @id
+            else
+                return nil
+            end
+        end
+    end
 
+    #A cron entry ...
     class CronEntry
         DEFAULTS = {
             :minute => '*',
@@ -262,73 +507,4 @@ end
 
 if  __FILE__ == $0
     include CronEdit
-    
-
-    
-
-    ents = [
-        CronEntry.new( "5,35 0-23/2 * * * echo 123" ),
-        CronEntry.new,
-        CronEntry.new( {:minute=>5, :command=>'echo 42'} ),
-    ]
-    ents.each { |e| puts e }
-
-    e= CronEntry.new( "5,35 0-23/2 * * * echo 123" )
-    puts "Minute: #{e[:minute].inspect}"
-    puts "Hour: #{e[:hour].inspect}"
-    puts "Day: #{e[:day].inspect}"
-    p e.to_s
-    p e.to_hash
-    p e.to_raw
-
-    begin
-        CronEntry.new( {:minuteZ=>5, :command=>'echo 42'} )
-        puts "Failure failed"
-    rescue         
-    end
-
-    begin
-        CronEntry.new( "1-85 2 * * * echo 123" )
-        puts "Failure failed"
-    rescue  CronEntry::FormatError
-    end
-
-    crontabTest=%Q{
-    5,35 0-23/2 * * * echo 123
-    #agent1
-    3 * * * * echo agent1
-
-
-    #agent2
-    3 * * * * echo agent2
-    #ignored comment
-    #agent1
-    3 * * * * echo agent3
-  }
-    puts "Crontab raw:  #{Crontab.new.listRaw.inspect}"
-    puts "Crontab:  #{Crontab.new.list.inspect}"
-    puts "Crontab test:  #{Crontab.new.parseCrontab(crontabTest).inspect }"
-
-    #rollback test
-    cm = Crontab.new
-    cm. add 'agent1', '5,35 0-23/2 * * * "echo 123" '
-    cm.remove "agent2"
-    cm.review
-    cm.rollback
-    
-    #commit test
-    cm = Crontab.new
-    cm. add "agent1", "5,35 0-23/2 * * * echo agent1" 
-    cm. add "agent2", "0 2 * * * echo agent2" 
-    cm.commit
-    current=cm.list
-    puts "New crontab 1:  #{current.inspect}"  
-    
-    cm = Crontab.new
-    cm. add "agent1", '59 * * * * echo "modified agent1"'
-    cm.remove "agent2"
-    cm.commit
-    current=Crontab.List 
-    puts "New crontab 2:  #{current.inspect}"
-    raise "Assertion" unless current=={'agent1'=> '59 * * * * echo "modified agent1"'}
 end

data/test/cronedit_test.rb

@@ -2,14 +2,37 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
 require 'test/unit'
 require 'cronedit.rb'
+require 'stringio'
 include CronEdit
 
+class Class
+  def publicize_methods
+    saved_private_instance_methods = self.private_instance_methods
+    saved_protected_instance_methods = self.protected_instance_methods
+    self.class_eval { public(*saved_private_instance_methods) }
+    self.class_eval { public(*saved_protected_instance_methods) }
+    yield
+    self.class_eval { protected(*saved_protected_instance_methods) }
+    self.class_eval { private(*saved_private_instance_methods) }
+  end
+end
+
 class CronEdit_test < Test::Unit::TestCase
-#  def setup
-#  end
-#
-#  def teardown
-#  end
+  def setup
+        #backup crontab
+        `crontab -l > /tmp/crontab.bak`
+  end
+
+  def teardown
+        #restore crontab
+        `crontab  /tmp/crontab.bak`
+  end
+
+    def test_idParsing
+        idin=['##__id1__', '   ##__id3__', '#the end comment','kuk','##___id4___','###__id5__']
+        out = idin.map {|l| CronEdit::EntryPlaceholder.ScanId(l)}
+        assert_equal(['id1',nil,nil,nil,'_id4_',nil], out, "idParsing")
+    end
 
     def test_creation
         e = CronEntry.new( "5,35 0-23/2 * * * echo 123" )
@@ -29,11 +52,12 @@ class CronEdit_test < Test::Unit::TestCase
         assert_equal( "0,2,4,6,8,10,12,14,16,18,20,22", e[:hour])
         assert_equal( "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31", e[:day])
     end
-  def test_wrongformat
+
+    def test_wrongformat
         assert_raise(CronEntry::FormatError){
             CronEntry.new( "1-85 2 * * * echo 123" )
         }
-  end
+    end
 
     def test_wrongconfog
         assert_raise(RuntimeError){
@@ -42,29 +66,39 @@ class CronEdit_test < Test::Unit::TestCase
     end
   
     def test_zip
-        crontabTest=%Q{
-        5,35 0-23/2 * * * echo 123
-        #agent1
-        3 * * * * echo agent1
+        Crontab.publicize_methods {
+            crontabTest=%Q{
+            5,35 0-23/2 * * * echo 123
+            ##__agent1__
+            3 * * * * echo agent1
 
 
-        #agent2
-        3 * * * * echo agent2
-        #ignored comment
-        #agent1
-        3 * * * * echo agent3
-    }
-        expected = {"agent1"=>"3 * * * * echo agent3", "agent2"=>"3 * * * * echo agent2", "1"=>"5,35 0-23/2 * * * echo 123"}
-        assert_equal( expected, Crontab.new.parseCrontab(crontabTest), 'parsing of crontab file')
+            ##__agent2__
+            3 * * * * echo agent2
+            #ignored comment
+            ##__agent1__
+            3 * * * * echo agent3
+        }
+            expected = {"agent1"=>"3 * * * * echo agent3", "agent2"=>"3 * * * * echo agent2", "1"=>"5,35 0-23/2 * * * echo 123"}
+            assert_equal( expected, Crontab.new.parseCrontab(crontabTest), 'parsing of crontab file')
+        }
     end
 
     def test_emptycrontab
-        assert_equal( [], Crontab.new.listRaw )
-        assert_equal( {}, Crontab.new.list )
+        input = 'no crontab for user'
+        assert_equal( {}, Crontab.new.setIO(StringIO.new(input),nil).list )
+    end
+
+    def test_clear
+        Crontab.new.clear!
+        entries, lines = Crontab.new.listFull
+        assert_equal( {}, entries,  "Entries"    )
+        Crontab.new.list
     end
 
     def test_rollback
         #rollback test
+        `crontab -r`; `crontab -d`
         assert_equal( {}, Crontab.new.list, 'precondition' )
         cm = Crontab.new
         cm. add 'agent1', '5,35 0-23/2 * * * "echo 123" '
@@ -74,7 +108,68 @@ class CronEdit_test < Test::Unit::TestCase
         assert_equal( {}, Crontab.new.list )
     end
 
+    def test_complex
+        Crontab.publicize_methods {
+            File.open( File.join(File.dirname(__FILE__), 'testcron.txt') ) { |f|
+                content = f.read
+                f.rewind
+                entries, lines = Crontab.new.parseCrontabFull f
+                assert_equal 12, lines.length, "Lines"
+                assert_equal ['1','2','3','test'].sort, entries.keys.sort, "Entries"
+                #puts "--------------Lines:  \n#{lines.join("\n") }"
+                #puts "--------------entries:  \n#{entries.map {|k,v| "#{k}=>#{v}\n"} }"
+                output = StringIO.new
+                Crontab.new.dumpCron  entries, lines, output
+                #puts "OUT: #{output.string}"
+                #loop
+                output.rewind
+                entries2, lines2 = Crontab.new.parseCrontabFull output
+                assert_equal 12, lines2.length, "Lines2"
+                assert_equal ['1','2','3','test'].sort, entries2.keys.sort, "Entries2"
+            }
+        }
+    end
+
+    def test_complex2
+        crontabTest=%Q{
+    MAIL = user
+    ##__agent1__
+    3 * * * * echo agent1
+
+    
+    #comment
+    3 * * * * echo agent2
+    
+    ##__blankId__
+    #anonymous
+    3 * * * * echo anonymous
+    }
+        ct = Crontab.new
+        ct.setIO StringIO.new(crontabTest), nil
+        entries, lines = ct.listFull
+        assert_equal 11, lines.length, "Lines"
+        assert_equal ['agent1','1','2'].sort, entries.keys.sort, "Entries"
+##        puts "--------------Lines:  \n#{lines.join("\n") }"
+##        puts "--------------entries:  \n#{entries.map {|k,v| "#{k}=>#{v}\n"} }"
+
+        ct.add 'agent1', '5,35 0-23/2 * * * echo agent1'   #overwriting
+        ct.add 'agent3', '0 2 * * * echo agent3'   #new agent
+        ct.remove '2'
+        output = StringIO.new
+        ct.setIO StringIO.new(crontabTest), output
+        ct.commit
+##        puts '-'*40 + "\n#{output.string}\n" + '-'*40
+        # loop
+        ct.setIO StringIO.new(output.string), nil
+        entries, lines = ct.listFull
+        assert_equal 11, lines.length, "Lines"
+        assert_equal ['agent1','agent3','1'].sort, entries.keys.sort, "Entries"
+##        puts "--------------Lines:  \n#{lines.join("\n") }"
+##        puts "--------------entries:  \n#{entries.map {|k,v| "#{k}=>#{v}\n"} }"
+    end
+
     def test_commit
+            `crontab -r`; `crontab -d`
             assert_equal( {}, Crontab.new.list, 'precondition' )
             cm = Crontab.new
             cm. add "agent1", "5,35 0-23/2 * * * echo agent1" 
@@ -96,4 +191,105 @@ class CronEdit_test < Test::Unit::TestCase
             assert_equal( {}, Crontab.List, 'precondition' )
     end
 
+    def test_classMethods
+        Crontab.List
+    end
+
+    def test_filecrontab
+        fc = FileCrontab.new File.join(File.dirname(__FILE__), 'testcron.txt'), '/tmp/crontest.txt'
+        fc.add 'file', '59 * * * * echo "file"'
+        fc.remove 2, 3
+        fc.commit
+        # check it
+        entries, lines = FileCrontab.new( '/tmp/crontest.txt',nil).listFull
+        assert_equal 11, lines.length, "Lines"
+        assert_equal ['1','test','file'].sort, entries.keys.sort, "Entries"
+    end
+
+    def test_filecrontab2
+        fc = FileCrontab.new nil,  '-'
+        fc.add 'agent', '59 * * * * echo 123'
+        fc.commit
+        #todo: how to test STDOUT
+
+        fc = FileCrontab.new nil,  '/tmp/crontest.txt'
+        fc.add 'agent', '59 * * * * echo 123'
+        fc.commit
+        File.open( '/tmp/crontest.txt') {
+            |f|
+            assert_equal f.read, "##__agent__\n59 * * * * echo 123\n"
+        }
+    end
+
+    def test_dummycrontab
+        fc = DummyCrontab.new
+        fc.add 'agent1', '59 * * * * echo "agent1"'
+        fc.add 'agent2', {:hour=>'2',:command=>'echo "huh"'}
+        fc.commit
+        #check 1
+        output = fc.to_s
+        entries, lines = Crontab.new.setIO(StringIO.new(output),nil).listFull
+        assert_equal 2, lines.length, "Lines"
+        assert_equal ['agent1','agent2'].sort, entries.keys.sort, "Entries"
+        #continue editing
+        fc.remove 'agent2'
+        fc.commit
+        #check 2
+        output = fc.to_s
+        entries, lines = Crontab.new.setIO(StringIO.new(output),nil).listFull
+        assert_equal 1, lines.length, "Lines"
+        assert_equal ['agent1'].sort, entries.keys.sort, "Entries"
+    end
+
+    def test_merge
+        fc1 = DummyCrontab.new
+        fc1.add 'agent1', '59 * * * * echo "agent1"'
+        fc1.add 'agent2', {:hour=>'2',:command=>'echo "huh"'}
+        fc1.commit
+    
+        fc2 = DummyCrontab.new
+        fc2.add 'agent3', '59 * * * * echo "agent3"'
+        fc2.remove 'agent2'
+        
+        fc1.merge fc2
+        fc1.commit
+        output = fc1.to_s
+        entries, lines = Crontab.new.setIO(StringIO.new(output),nil).listFull
+        assert_equal 2, lines.length, "Lines"
+        assert_equal ['agent1','agent3'].sort, entries.keys.sort, "Entries"    
+    end
+
+    def test_mergeWithFile
+        fc1 = FileCrontab.new File.join(File.dirname(__FILE__), 'testcron.txt')
+    
+        fc2 = DummyCrontab.new
+        fc2.add 'agent3', '59 * * * * echo "agent3"'
+        
+        fc2.merge fc1
+        fc2.commit
+        output = fc2.to_s
+##        puts "\n\n"+output
+        entries, lines = Crontab.new.setIO(StringIO.new(output),nil).listFull
+        assert_equal 5, lines.length, "Lines"
+        assert_equal ['1','2','3','test','agent3'].sort, entries.keys.sort, "Entries"    
+    end
+
+    def test_subtractFile
+        fc1 = DummyCrontab.new
+        fc1.add 'test', '59 * * * * echo "whatever"'
+        fc1.add 'test2', '59 * * * * echo "whatever"'
+        fc1.add '3', '59 * * * * echo "whatever"'
+        fc1.commit
+
+    
+        fc2= FileCrontab.new File.join(File.dirname(__FILE__), 'testcron.txt')
+        fc1.subtract fc2
+        fc1.commit
+        output = fc1.to_s
+##        puts "\n\n"+output
+        entries, lines = Crontab.new.setIO(StringIO.new(output),nil).listFull
+        assert_equal 1, lines.length, "Lines"
+        assert_equal ['test2'].sort, entries.keys.sort, "Entries"    
+    end
+
 end

data/test/examples/example1.cron

@@ -0,0 +1,4 @@
+##__echo1__
+* * * * * echo 1 >> /tmp/echo.log
+##__echo2__
+* * * * * echo 2 >> /tmp/echo.log

data/test/examples/examples.rb

@@ -0,0 +1,51 @@
+$:.unshift File.join(File.dirname(__FILE__),'../..','lib')
+require 'cronedit.rb' 
+include CronEdit
+
+# 1. Direct cron modifications
+Crontab.Add  'agent1', '5,35 0-23/2 * * * echo agent1'
+Crontab.Add  'agent2', {:minute=>5, :command=>'echo 42'}
+p Crontab.List
+Crontab.Remove 'agent1', 'agent2'
+
+# 2. Batch modification
+cm = Crontab.new
+cm.add :agent1, '5,35 0-23/2 * * * echo "agent1" >> /tmp/agent/log'
+cm.add :agent2, {:minute=>5, :command=>'echo 42'}
+cm.commit
+p cm.list
+
+
+#3. Delete crontab completely
+cm.clear!
+
+# 4. Bulk merge from file using FileCrontab
+fc = FileCrontab.new File.join(File.dirname(__FILE__), 'example1.cron')
+# Add all entries from file
+Crontab.Merge fc
+p Crontab.List
+# An an entry manually
+Crontab.Add  :test, '* * * * * test'
+# Remove all entries defined in the file
+Crontab.Subtract fc
+p Crontab.List 
+
+# 5. Read from file - output to STDOUT (you can use a file instead of STDOUT)
+fc = FileCrontab.new File.join(File.dirname(__FILE__), 'example1.cron'), '-'
+fc.add :agent2, {:minute=>5, :command=>'echo 42'}
+fc.commit
+
+
+# 6. DummyCrontab - in memory crontab
+dc = DummyCrontab.new
+dc.add 'agent1', '59 * * * * echo "agent1"'
+dc.add 'agent2', {:hour=>'2',:command=>'echo "huh"'}
+dc.commit
+puts dc
+
+# 7. Of course you can combine (merge/subtract) all types of Crontabs, ie. Crontab, FileCrontab, DummyCrontab
+
+# 8. In case you need to read/write crontab definition from/to yet another source (stream) use setIO method
+require 'stringio'
+output = "#read from DB"
+p Crontab.new.setIO(StringIO.new(output),nil).list

data/test/testcron.txt

@@ -0,0 +1,14 @@
+MAILTO=user
+SHELL = /bin/bash
+
+# * * * * wed,sat /usr/bin/ruby -C /sync test.rb run
+0 20 * * * /tmp/agent1
+# this is a comment - to be preserved
+
+##__test__
+2	*	*	*	*	/verycomplicated/script 123 >> /tmp/xml_server.log 2>&1
+
+##__test2__
+# id is lost?
+0 21 * * * /sync/exec_with_env.sh jobstream_generate.rb --lang en --fulladmin run
+0 21 * * * /sync/exec_with_env.sh sync_master.rb --monitconf /etc/monitrc-200 --downtimeFrom '22:00' --downtimeTo '23:00' run

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: cronedit
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2007-12-09 00:00:00 +01:00
+  version: 0.3.0
+date: 2008-02-04 00:00:00 +01:00
 summary: CronEdit is a Ruby editor library for crontab.
 require_paths: 
 - lib
@@ -30,6 +30,11 @@ authors:
 - Viktor Zigo
 files: 
 - lib/cronedit.rb
+- test/testcron.txt
+- test/examples
+- test/examples/example1.cron
+- test/examples/examples.rb
+- test/cronedit_test.rb
 test_files: 
 - test/cronedit_test.rb
 rdoc_options: []