adding markers

git-svn-id: https://reductivelabs.com/svn/puppet/library/trunk@174 980ebf18-57e1-0310-9a29-db15c13687c0

1 files changed, 80 insertions, 2 deletions

diff --git a/lib/blink/types/filetype.rb b/lib/blink/types/filetype.rb
index 4cf8ba1d8..4848c16b7 100644
--- a/lib/blink/types/filetype.rb
+++ b/lib/blink/types/filetype.rb
@@ -15,35 +15,50 @@ module Blink
 
         @@classes = Hash.new(nil)
 
+		#---------------------------------------------------------------
         def FileType.[](name)
             return @@classes[name]
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def FileType.childtype=(childtype)
             @childtype = childtype
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def FileType.childtype
             return @childtype
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def FileType.name=(name)
             @name = name
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def FileType.regex
             return @regex
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def FileType.splitchar=(splitchar)
             @regex = %r{#{splitchar}}
             @splitchar = splitchar
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def FileType.splitchar
             return @splitchar
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def FileType.newtype(arghash)
             options = [:name, :linesplit, :recordsplit, :fields, :namevar]
 
@@ -93,14 +108,20 @@ module Blink
 
             return klass
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def [](name)
             return @childhash[name]
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def []=(name,value)
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         # we don't really have a 'less-than/greater-than' sense here
         # so i'm sticking with 'equals' until those make sense
         def ==(other)
@@ -121,7 +142,9 @@ module Blink
 
             return equal
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def add(&block)
             obj = self.class.childtype.new(&block)
             Blink.debug("adding %s" % obj.name)
@@ -130,11 +153,15 @@ module Blink
 
             return obj
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def children
             return @childary
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def delete(name)
             if @childhash.has_key?(name)
                 child = @childhash[name]
@@ -145,20 +172,31 @@ module Blink
                 raise "No such entry %s" % name
             end
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def each
             @childary.each { |child|
                 yield child
             }
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
+        def fqpath
+        end
+		#---------------------------------------------------------------
+
+		#---------------------------------------------------------------
         def initialize(file)
             @file = file
 
             @childary = []
             @childhash = {}
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         # this is where we're pretty different from other objects
         # we can choose to either reparse the existing file and compare
         # the objects, or we can write our file out and do an
@@ -169,7 +207,9 @@ module Blink
 
             return self == tmp
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def retrieve
             str = ""
             File.open(@file) { |fname|
@@ -189,40 +229,53 @@ module Blink
                 @childhash[child.name] = child
             }
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def sync
             #unless self.insync?
                 self.write
             #end
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def to_s
             return @childary.collect { |child|
                 child.to_s
             }.join(self.class.splitchar) + self.class.splitchar
         end
+		#---------------------------------------------------------------
 
+		#---------------------------------------------------------------
         def write
             File.open(@file, "w") { |file|
                 file.write(self.to_s)
             }
         end
+		#---------------------------------------------------------------
     end
+    #---------------------------------------------------------------
 
+    #---------------------------------------------------------------
     class FileRecord < Blink::Interface
         attr_accessor :fields, :namevar, :splitchar
 
         @@subclasses = {}
 
+        #---------------------------------------------------------------
         def FileRecord.fields=(ary)
             @fields = ary
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def FileRecord.fields
             return @fields
         end
+        #---------------------------------------------------------------
 
-        #def FileRecord.newtype(name,splitchar,fields,namevar)
+        #---------------------------------------------------------------
         def FileRecord.newtype(*args)
             options = [:name, :splitchar, :fields, :namevar]
 
@@ -252,36 +305,52 @@ module Blink
 
             return klass
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def FileRecord.namevar=(field)
             @namevar = field
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def FileRecord.namevar
             return @namevar
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def FileRecord.regex
             return @regex
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def FileRecord.splitchar=(char)
             @splitchar = char
             @regex = %r{#{char}}
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def FileRecord.splitchar
             return @splitchar
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def [](field)
             @fields[field]
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def []=(field,value)
             @fields[field] = value
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def ==(other)
             unless self.class == other.class
                 return false
@@ -298,15 +367,18 @@ module Blink
             }
             return true
         end
+        #---------------------------------------------------------------
 
-
+        #---------------------------------------------------------------
         def initialize
             @fields = {}
             if block_given?
                 yield self
             end
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def record=(record)
             ary = record.split(self.class.regex)
             self.class.fields.each { |field|
@@ -314,7 +386,9 @@ module Blink
                 #puts "%s => %s" % [field,@fields[field]]
             }
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def name
             if @fields.include?(self.class.namevar)
                 return @fields[self.class.namevar]
@@ -322,7 +396,9 @@ module Blink
                 raise "No namevar for objects of type %s" % self.class.to_s
             end
         end
+        #---------------------------------------------------------------
 
+        #---------------------------------------------------------------
         def to_s
             ary = self.class.fields.collect { |field|
                 if ! @fields.include?(field)
@@ -332,5 +408,7 @@ module Blink
                 end
             }.join(self.class.splitchar)
         end
+        #---------------------------------------------------------------
     end
+    #---------------------------------------------------------------
 end