i am giving up on fileparsing for now; it does not work yet

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

7 files changed, 164 insertions, 72 deletions

diff --git a/lib/blink/client.rb b/lib/blink/client.rb
index 1715ab8f5..ea5c449d4 100644
--- a/lib/blink/client.rb
+++ b/lib/blink/client.rb
@@ -22,6 +22,8 @@ module Blink
     class Client < SOAP::RPC::HTTPServer
         def initialize(hash)
             # to whom do we connect?
+            @server = nil
+            @nil = nil
             @url = hash[:Server]
             if hash.include?(:Listen) and hash[:Listen] == false
                 Blink.notice "We're local"
@@ -61,9 +63,7 @@ module Blink
         # manipulations
         def config(tree)
             Blink.notice("Calling config")
-            Blink.verbose tree.inspect
             container = Marshal::load(tree).to_type
-            #Blink.verbose container.inspect
 
             # for now we just evaluate the top-level container, but eventually
             # there will be schedules and such associated with each object,
diff --git a/lib/blink/transportable.rb b/lib/blink/transportable.rb
index 48dee6423..afb6f8061 100644
--- a/lib/blink/transportable.rb
+++ b/lib/blink/transportable.rb
@@ -54,16 +54,17 @@ module Blink
                     self[namevar] = self[:name]
                     self.delete(:name)
                 end
-                begin
+                p self
+                #begin
                     # this will fail if the type already exists
                     # which may or may not be a good thing...
                     retobj = type.new(self)
-                rescue => detail
-                    Blink.error "Failed to create object: %s" % detail 
-                    #puts object.class
-                    #puts object.inspect
-                    #exit
-                end
+                #rescue => detail
+                #    Blink.error "Failed to create %s: %s" % [type.name,detail]
+                #    puts self.class
+                #    puts self.inspect
+                #    exit
+                #end
             else
                 raise "Could not find object type %s" % self.type
             end
@@ -125,7 +126,7 @@ module Blink
                     # exists in our scope
                     # this assumes that type/name combinations are globally
                     # unique
-                    name = [child[:name],child[:type]].join("--")
+                    name = [child[:name],child.type].join("--")
 
                     if nametable.include?(name)
                         object = nametable[name]
@@ -133,6 +134,7 @@ module Blink
                             # don't rename; this shouldn't be possible anyway
                             next if var == :name
 
+                            Blink.notice "Adding %s to %s" % [var,name]
                             # override any existing values
                             object[var] = value
                         }
diff --git a/lib/blink/type.rb b/lib/blink/type.rb
index 7ca72c5c1..1b7f0e252 100644
--- a/lib/blink/type.rb
+++ b/lib/blink/type.rb
@@ -133,7 +133,7 @@ class Blink::Type < Blink::Element
     def Type.inherited(sub)
         sub.initvars
 
-        Blink.debug("subtype %s just created" % sub)
+        #Blink.notice("subtype %s(%s) just created" % [sub,sub.superclass])
         # add it to the master list
         # unfortunately we can't yet call sub.name, because the #inherited
         # method gets called before any commands in the class definition
@@ -148,8 +148,13 @@ class Blink::Type < Blink::Element
     def Type.initvars
         @objects = Hash.new
         @actions = Hash.new
+        #Blink.verbose "initing validstates for %s" % self
         @validstates = {}
         @validparameters = {}
+
+        unless defined? @states
+            @states = {}
+        end
     end
     #---------------------------------------------------------------
 
@@ -280,12 +285,32 @@ class Blink::Type < Blink::Element
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
+    # this is probably only used by FileRecord objects
+    def Type.parameters=(params)
+        Blink.notice "setting parameters to [%s]" % params.join(" ")
+        @parameters = params.collect { |param|
+            if param.class == Symbol
+                param
+            else
+                param.intern
+            end
+        }
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
     def Type.states
         return @states
     end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
+    def Type.validstates
+        return @validstates
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
     def Type.validstate(name)
         unless @validstates.length == @states.length
             self.buildstatehash
@@ -396,6 +421,14 @@ class Blink::Type < Blink::Element
         @notify = Hash.new
         @actions = Hash.new
 
+        # convert all strings to symbols
+        hash.each { |var,value|
+            unless var.is_a? Symbol
+                hash[var.intern] = value
+                hash.delete(var)
+            end
+        }
+
         # if they passed in a list of states they're interested in,
         # we mark them as "interesting"
         # XXX maybe we should just consider params set to nil as 'interesting'
@@ -408,9 +441,9 @@ class Blink::Type < Blink::Element
             hash.delete(:check)
         end
 
-        if hash.include?("noop")
-            @noop = hash["noop"]
-            hash.delete("noop")
+        if hash.include?(:noop)
+            @noop = hash[:noop]
+            hash.delete(:noop)
         end
 
         # states and parameters are treated equivalently from the outside:
@@ -523,6 +556,10 @@ class Blink::Type < Blink::Element
     # this returns any changes resulting from testing, thus 'collect'
     # rather than 'each'
     def evaluate
+        unless defined? @evalcount
+            Blink.error "No evalcount defined on '%s' of type '%s'" %
+                [self.name,self.class]
+        end
         # if we're a metaclass and we've already evaluated once...
         if self.metaclass and @evalcount > 0
             return
@@ -596,3 +633,6 @@ require 'blink/type/symlink'
 require 'blink/type/package'
 require 'blink/type/component'
 require 'blink/statechange'
+require 'blink/type/typegen'
+require 'blink/type/typegen/filetype'
+require 'blink/type/typegen/filerecord'
diff --git a/lib/blink/type/component.rb b/lib/blink/type/component.rb
index 43906f749..91eff0390 100644
--- a/lib/blink/type/component.rb
+++ b/lib/blink/type/component.rb
@@ -29,6 +29,7 @@ module Blink
         def push(*ary)
             ary.each { |child|
                 unless child.is_a?(Blink::Element)
+                    Blink.notice "Got object of type %s" % child.class
                     raise "Containers can only contain Blink::Elements"
                 end
                 @children.push child
diff --git a/lib/blink/type/typegen.rb b/lib/blink/type/typegen.rb
index 9643d8462..104e79aef 100644
--- a/lib/blink/type/typegen.rb
+++ b/lib/blink/type/typegen.rb
@@ -7,10 +7,12 @@
 require 'etc'
 require 'blink/type'
 
-class Blink::Type::TypeGenerator < Blink::Type
+module Blink
+    class Type
+class TypeGenerator < Blink::Type
     include Enumerable
 
-    @namevar = :notused
+    @namevar = :name
     @name = :typegen
     @abstract = true
 
@@ -22,13 +24,17 @@ class Blink::Type::TypeGenerator < Blink::Type
 
     #---------------------------------------------------------------
     def TypeGenerator.inherited(subclass)
-        subclass.initvars
+        #subclass.initvars
+        super(subclass)
     end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
+    # we don't need to 'super' here because type.rb already runs initvars
+    # in Type#inherited
     def TypeGenerator.initvars
         @subclasses = Hash.new(nil)
+        super
     end
     #---------------------------------------------------------------
 
@@ -46,25 +52,42 @@ class Blink::Type::TypeGenerator < Blink::Type
 
     #---------------------------------------------------------------
     def TypeGenerator.namevar
-        return :notused
+        return @namevar || :name
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def TypeGenerator.namevar=(namevar)
+        Blink.debug "Setting namevar for %s to %s" % [self,namevar]
+        unless namevar.is_a? Symbol
+            namevar = namevar.intern
+        end
+        @namevar = namevar
     end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
     def TypeGenerator.newtype(arghash)
-        unless defined? @options
+        unless defined? @parameters
             raise "Type %s is set up incorrectly" % self
         end
 
         arghash.each { |key,value|
-            unless @options.include?(key)
+            if key.class != Symbol
+                # convert to a symbol
+                arghash[key.intern] = value
+                arghash.delete key
+                key = key.intern
+            end
+            unless @parameters.include?(key)
                 raise "Invalid argument %s on class %s" %
                     [key,self]
             end
+
         }
 
         # turn off automatically checking all arguments
-        #@options.each { |option|
+        #@parameters.each { |option|
         #    unless arghash.include?(option)
         #        p arghash
         #        raise "Must pass %s to class %s" %
@@ -100,7 +123,7 @@ class Blink::Type::TypeGenerator < Blink::Type
         # i couldn't get the method definition stuff to work
         # oh well
         # probably wouldn't want it in the end anyway
-        #@options.each { |option|
+        #@parameters.each { |option|
         #    writer = option.id2name + "="
         #    readproc = proc { eval("@" + option.id2name) }
         #    klass.send(:define_method,option,readproc)
@@ -109,8 +132,12 @@ class Blink::Type::TypeGenerator < Blink::Type
         #    klass.send(writer,hash[option])
         #}
 
+        #Blink::Type.inherited(klass)
+        Blink::Type.buildtypehash
         return klass
     end
     #---------------------------------------------------------------
 end
 #---------------------------------------------------------------
+end
+end
diff --git a/lib/blink/type/typegen/filerecord.rb b/lib/blink/type/typegen/filerecord.rb
index 8c7c042b5..fb9030c12 100644
--- a/lib/blink/type/typegen/filerecord.rb
+++ b/lib/blink/type/typegen/filerecord.rb
@@ -12,18 +12,24 @@ require 'blink/type/typegen'
 class Blink::Type::FileRecord < Blink::Type::TypeGenerator
     attr_accessor :fields, :namevar, :splitchar, :object
 
-    @options = [:name, :splitchar, :fields, :namevar, :filetype, :regex, :joinchar]
+    @parameters = [:name, :splitchar, :fields, :namevar, :filetype, :regex, :joinchar]
     @abstract = true
     @metaclass = true
 
+    @namevar = :name
     @name = :filerecord
 
     #---------------------------------------------------------------
     def FileRecord.newtype(hash)
-        shortname = hash[:name]
-        hash[:name] = hash[:filetype].name.capitalize + hash[:name].capitalize
+        #shortname = hash[:name]
+        #hash[:name] = hash[:filetype].name.capitalize + hash[:name].capitalize
         klass = super(hash)
-        klass.name = shortname
+        #klass.name = shortname
+        klass.parameters = hash[:fields]
+        #klass.namevar = hash[:namevar]
+        klass.filetype = hash[:filetype]
+        hash.delete(:fields)
+        hash.delete(:namevar)
         return klass
     end
     #---------------------------------------------------------------
@@ -48,7 +54,13 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
 
     #---------------------------------------------------------------
     def FileRecord.filetype=(filetype)
-        @filetype = filetype
+        if filetype.is_a?(String)
+            @filetype = Blink::Type::FileType[filetype]
+        elsif filetype.is_a?(Blink::Type::FileType)
+            @filetype = filetype
+        else
+            raise "Cannot use objects of type %s as filetypes" % filetype 
+        end
     end
     #---------------------------------------------------------------
 
@@ -87,18 +99,6 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
-    def FileRecord.namevar=(field)
-        @namevar = field
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
-    def FileRecord.namevar
-        return @namevar
-    end
-    #---------------------------------------------------------------
-
-    #---------------------------------------------------------------
     def FileRecord.regex=(regex)
         @regex = regex
     end
@@ -148,15 +148,15 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
-    def [](field)
-        @fields[field]
-    end
+    #def [](field)
+    #    @parameters[field]
+    #end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
-    def []=(field,value)
-        @fields[field] = value
-    end
+    #def []=(field,value)
+    #    @parameters[field] = value
+    #end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
@@ -168,7 +168,7 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
         unless self.name == other.name
             return false
         end
-        @fields.keys { |field|
+        @parameters.keys { |field|
             unless self[field] == other[field]
                 Blink.debug("%s -> %s has changed" % [self.name, field])
                 return false
@@ -179,12 +179,16 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
-    def initialize(object)
-        @object = object
-        @fields = {}
-        if block_given?
-            yield self
+    def initialize(hash)
+        if self.class == Blink::Type::FileRecord
+            self.class.newtype(hash)
+            return
         end
+        @parameters = {}
+        #if block_given?
+        #    yield self
+        #end
+        super(hash)
     end
     #---------------------------------------------------------------
 
@@ -193,8 +197,8 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
         @match = matchobj
         #puts "captures are [%s]" % [matchobj.captures]
         self.class.fields.zip(matchobj.captures) { |field,value|
-            @fields[field] = value
-            #puts "%s => %s" % [field,@fields[field]]
+            @parameters[field] = value
+            #puts "%s => %s" % [field,@parameters[field]]
         }
     end
     #---------------------------------------------------------------
@@ -207,18 +211,19 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
             raise RegexpError.new(detail)
         end
         self.class.fields.each { |field|
-            @fields[field] = ary.shift
-            #puts "%s => %s" % [field,@fields[field]]
+            @parameters[field] = ary.shift
+            #puts "%s => %s" % [field,@parameters[field]]
         }
     end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
     def name
-        if @fields.include?(self.class.namevar)
-            return @fields[self.class.namevar]
+        if @parameters.include?(self.class.namevar)
+            return @parameters[self.class.namevar]
         else
-            raise "No namevar for objects of type %s" % self.class.to_s
+            raise "No namevar '%s' for objects of type %s" %
+                [self.class.namevar,self.class.to_s]
         end
     end
     #---------------------------------------------------------------
@@ -226,10 +231,10 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
     #---------------------------------------------------------------
     def to_s
         ary = self.class.fields.collect { |field|
-            if ! @fields.include?(field)
+            if ! @parameters.include?(field)
                 raise "Object %s is missing field %s" % [self.name,field]
             else
-                @fields[field]
+                @parameters[field]
             end
         }.join(self.class.joinchar || self.class.splitchar)
     end
diff --git a/lib/blink/type/typegen/filetype.rb b/lib/blink/type/typegen/filetype.rb
index 44cb76826..4b3b89db8 100644
--- a/lib/blink/type/typegen/filetype.rb
+++ b/lib/blink/type/typegen/filetype.rb
@@ -10,10 +10,11 @@ require 'blink/type/typegen'
 class Blink::Type::FileType < Blink::Type::TypeGenerator
     attr_accessor :childtype
 
-    @options = [:name, :linesplit, :escapednewlines]
-    @abstract = true
+    @parameters = [:name, :linesplit, :escapednewlines]
+    #@abstract = true
     @metaclass = true
 
+    @namevar = :name
     @name = :filetype
 
     @modsystem = true
@@ -23,9 +24,14 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
         unless hash.include?(:linesplit)
             hash[:linesplit] = "\n"
         end
+
+        # i don't think there's any reason to 'super' this
+        #klass = Blink::Type::TypeGenerator.newtype(hash)
         klass = super(hash)
 
         klass.escapednewlines = true
+        klass.namevar = :name
+        klass.parameters = [:name, :path, :complete]
 
         #klass.childtype = Blink::Type::FileRecord.newtype(
         #    :name => hash[:name] + "_record",
@@ -119,14 +125,14 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
-    def [](name)
-        return @childhash[name]
-    end
+    #def [](name)
+    #    return @childhash[name]
+    #end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
-    def []=(name,value)
-    end
+    #def []=(name,value)
+    #end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
@@ -194,11 +200,22 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
 
     #---------------------------------------------------------------
     # create a new file
-    def initialize(file)
-        @file = file
+    def initialize(hash)
+        # if we are the FileType object itself, we create a new type
+        # otherwise, we create an instance of an existing type
+        # yes, this should be more straightforward
+        if self.class == Blink::Type::FileType
+            self.class.newtype(hash)
+            return
+        end
+        Blink.debug "Creating new '%s' file with path '%s' and name '%s'" %
+            [self.class.name,hash["path"],hash[:name]]
+        Blink.debug hash.inspect
+        @file = hash["path"]
 
         @childary = []
         @childhash = {}
+        super
     end
     #---------------------------------------------------------------
 
@@ -216,9 +233,9 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------
-    def name
-        return @file
-    end
+    #def name
+    #    return @file
+    #end
     #---------------------------------------------------------------
 
     #---------------------------------------------------------------