redcar 0.2.9dev

data/lib/freebase2/lib/freebase/properties.rb

@@ -0,0 +1,130 @@
+# Purpose: FreeBASE properties Manager. 
+#    
+# $Id: properties.rb,v 1.6 2005/02/27 16:18:29 ljulliar Exp $
+#
+# Authors:  Rich Kilmer <rich@infoether.com>
+# Contributors:
+#
+# This file is part of the FreeRIDE project
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# COPYING file.
+# 
+# Copyright (c) 2001 Rich Kilmer. All rights reserved.
+#
+
+module FreeBASE
+
+  ##
+  # The Properties class sits on top of the databus
+  # and persists the tree of values in an xml file
+  #
+  class Properties
+    attr_reader :base_slot
+    attr_accessor :auto_save
+    
+    ##
+    # test if a property file exists either in the user
+    # or the FR directory
+    #
+    def self.exist?(filespec)
+      user_filespec = DefaultPropertiesReader.user_filename(filespec)
+      if user_filespec.nil?
+        filespec = File.join($FR_CODEBASE,filespec) unless File.absolute_path?(filespec)
+      else
+        filespec = user_filespec
+      end
+      File.exist?(filespec)
+    end
+
+    ##
+    # Copy a property file from source file to target file
+    # Try to copy to user directory first else FR directory
+    #
+    def self.copy(filespec_src, filespec_tgt)
+      require 'ftools'
+      user_filespec_tgt = DefaultPropertiesReader.user_filename(filespec_tgt)
+      if user_filespec_tgt.nil?
+        filespec_tgt = File.join($FR_CODEBASE,filespec_tgt) unless File.absolute_path?(filespec_tgt)
+      else
+        filespec_tgt = user_filespec_tgt
+      end
+      filespec_src = File.join($FR_CODEBASE,filespec_src) unless File.absolute_path?(filespec_src)
+      File.makedirs(File.dirname(filespec_tgt))
+      File.copy(filespec_src, filespec_tgt)
+    end
+  
+    ##
+    # Creates a new Properties
+    #
+    # name:: [String] The name of this properties file
+    # version:: [String] The version of this properties file
+    # base_slot:: [FreeBASE::DataBus::Slot] The base slot of the branch to persist
+    # filespec:: [String] The file to store the properties in
+    #
+    def initialize(name, version, base_slot, filespec)
+      @base_slot = base_slot
+      @filespec = filespec
+      @name = name
+      @version = version
+      @auto_save = true
+      @base_slot.propagate_notifications = false
+      begin
+	DefaultPropertiesReader.load(@base_slot, @filespec)
+      rescue
+	@base_slot["/log/error"] << "Error loading property file: #{filespec}. Error: #{$!}. Ignoring it!"
+      end
+      @base_slot.propagate_notifications = true
+      @base_slot.manager = self
+      @base_slot.subscribe self
+    end
+    
+    ##
+    # Event handler for Slot change notifications
+    # see:: FreeRIDE::DataBus::Slot
+    #
+    def databus_notify(event, slot)
+      save if event == :notify_data_set && @auto_save
+    end
+    
+    def prune(path)
+      @base_slot[path].prune
+      save
+    end
+    
+    ##
+    # Gets the property value
+    #
+    # path:: [String] the property path
+    # return:: [String] the property value
+    #
+    def [](path)
+      return @base_slot[path].data
+    end
+    
+    ##
+    # Sets the property value and persists the properties
+    #
+    # path:: [String] the property path
+    # value:: [to_s] the property value
+    #
+    def []=(path, value)
+      @base_slot[path].data = value
+    end
+    
+    def each_property(path=".")
+      @base_slot[path].each_slot do |slot|
+        yield slot.name, slot.data
+      end
+    end
+    
+    ##
+    # Persists the properties file using the defined PropertiesReader
+    #
+    def save
+      DefaultPropertiesReader.save(@base_slot, @filespec, @name, @version)
+    end
+
+  end
+end

data/lib/freebase2/lib/freebase/readers.rb

@@ -0,0 +1,321 @@
+# Purpose: Configuration classes for FreeBASE
+#    
+# Authors:  Rich Kilmer <rich@infoether.com>
+# Contributors:
+#
+# This file is part of the FreeRIDE project
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# COPYING file.
+# 
+# Copyright (c) 2001 Rich Kilmer. All rights reserved.
+#
+begin
+  require 'rubygems'
+rescue
+end
+
+module FreeBASE
+
+  ##
+  # Reads and writes properties (properties.rb) to a persistent file in YAML
+  #
+  class YAMLPropertiesReader
+
+    @@userdir = nil
+  
+    def self.load_libraries
+      require 'yaml'
+    end
+    
+    ##
+    # Determine where the user directory is (if any)
+    #
+    def self.setup
+      $FREEBASE_APPLICATION = "redcar" unless $FREEBASE_APPLICATION
+      if RUBY_PLATFORM =~ /(mswin32|mingw32)/
+        if ENV['USERPROFILE'].nil?
+          @@userdir = "C:/My Documents/.redcar/"
+          Dir.mkdir(@@userdir) unless File.directory?(@@userdir)
+        else
+          @@userdir = File.join(ENV['USERPROFILE'], $FREEBASE_APPLICATION.downcase)
+        end
+      else
+        @@userdir = File.join(ENV['HOME'],".#{$FREEBASE_APPLICATION.downcase}") unless ENV['HOME'].nil?
+      end
+    end
+
+    ##
+    # Given a relative path to a property file, return the full path 
+    # in the user directory. Return nil if no user directory defined
+    # or absolute path name given.
+    #
+    def self.user_filename(filespec)
+      return nil if @@userdir.nil? || File.absolute_path?(filespec)
+      return File.expand_path(File.join(@@userdir,filespec))
+    end
+
+    ##
+    # Save a property file. Try in the user directory first then in the
+    # FR directory
+    #
+    def self.save(base_slot, filespec, name, version)
+      user_filespec = user_filename(filespec)
+      if user_filespec.nil?
+        filespec = File.join($FR_CODEBASE,filespec) unless File.absolute_path?(filespec)
+      else
+        filespec = user_filespec
+        # if file first saved make sure to create the full path first
+        unless File.exist?(filespec)
+          require 'ftools'
+          File.makedirs(File.dirname(filespec))
+        end
+      end
+      # puts ">>> Saving Property File: #{filespec}"
+      file = File.new(filespec,  "w+")
+      file.puts "#### Properties: #{name} - Version: #{version}"
+      file.puts gather_data(base_slot).to_yaml(:SortKeys=>true)
+      file.close
+    end
+    
+    def self.gather_data(slot, structure={})
+      structure[slot.name]=slot.data
+      if slot.has_child?
+        structure['|'] = Array.new
+        slot.each_slot do |child_slot|
+          map = {}
+          structure['|'] << map
+          gather_data(child_slot, map)
+        end
+      end
+      structure
+    end
+    
+    ##
+    # Load a property file. Try in the user directory first then in the
+    # FR directory
+    #
+    def self.load(base_slot, filespec)
+      user_filespec = user_filename(filespec)
+      if !user_filespec.nil? && File.exist?(user_filespec)
+        filespec = user_filespec
+      else
+        filespec = File.join($FR_CODEBASE,filespec) unless File.absolute_path?(filespec)
+      end
+      #puts "Loading Property File: #{filespec}"
+      return unless File.exist?(filespec)
+      data = nil
+      File.open(filespec) {|file| data = file.read}
+      map = YAML.load(data)
+      if map != nil
+        read_slot(base_slot, map)
+      end
+    end
+    
+    def self.read_slot(slot, map)
+      slot.data = map[map.keys.sort[0]]
+      return unless map["|"]
+      map['|'].each do |subslotmap|
+        read_slot(slot[subslotmap.keys.sort[0]], subslotmap)
+      end
+    end
+  end
+  
+  ##
+  # Reads and writes properties (properties.rb) to a persistent file in XML
+  #
+  class REXMLPropertiesReader
+  
+    def self.load_libraries
+      require 'rexml/document'
+    end
+    
+    def self.save(base_slot, filespec, name, version)
+      file = File.new(filespec,  "w+")
+      doc = REXML::Document.new "<properties name='#{name}' version='#{version}'/>"
+      base_slot.each_slot { |slot| write_slot(slot, doc.root) }
+      doc.write  file
+      file.close
+    end
+    
+    def self.write_slot(slot, root)
+      n_element = root.add_element("slot", {"name"=>slot.name})
+      n_element.text = slot.data
+      slot.each_slot { |child| write_slot(child, n_element) }
+    end
+    
+    def self.load(base_slot, filespec)
+      return unless File.exist?(filespec)
+      file = File.new(filespec)
+      doc = REXML::Document.new(file)
+      doc.root.each_element("slot") { |element| read_slot(base_slot, element) }
+      file.close
+    end
+      
+    def self.read_slot(root, element)
+      slot = root[element.attributes["name"]]
+      slot.data = element.text.strip if element.text
+      element.each_element("slot") { |element| read_slot(slot, element) }
+    end
+  end
+  
+  ##
+  # Reads the configuration files from the plugin path and registers the plugins
+  # with the Configuration (manager).
+  #
+  class YAMLConfigurationReader
+    def initialize(configuration)
+      @configuration = configuration
+      load_files
+    end
+    
+    def load_files
+      paths = @configuration.plugin_paths.split(";")
+      if defined? Gem
+        gems = Gem::SourceIndex.from_installed_gems(File.join(Gem.dir, "specifications"))
+        gems.each do |path, gem|
+          if gem.summary.include? "(#{$FREEBASE_APPLICATION} plugin)"
+            paths << Gem.dir+"/gems/"+path
+          end
+        end
+      end
+      load_files_from_paths(paths)
+    end
+    
+    private
+    
+    def load_files_from_paths(paths)
+      paths.each do |path|
+        fullpath = path
+        fullpath = File.join($FR_CODEBASE,path) unless File.absolute_path?(fullpath)
+        unless File.exists?(fullpath)
+          raise "can't find directory #{fullpath}"
+        end
+        Dir.foreach(fullpath) do |file|
+          next if file=='..' || file=='.'
+          if File.stat("#{fullpath}/#{file}").directory?
+            full_filespec = "#{fullpath}/#{file}/plugin.yaml"
+            filespec = "#{path}/#{file}/plugin.yaml"
+            next unless File.exist?(full_filespec)
+            @configuration.register(YAML.load(File.open(full_filespec).read),
+                                    File.dirname(filespec))
+          elsif file[-5..-1]==".yaml" and !File.stat("#{fullpath}/#{file}").directory?
+            full_filespec = "#{fullpath}/#{file}"
+            filespec = "#{path}/#{file}"
+            
+            # we absolutize the path here for gem plugins
+            yaml_spec = YAML.load(File.open(full_filespec).read)
+            yaml_spec.require_path = fullpath+"/"+yaml_spec.require_path
+            @configuration.register(yaml_spec,
+                                    File.dirname(filespec))
+          end
+        end
+      end
+    end
+  end
+  
+  # NOTE: NOT YET COMPLETE
+  class REXMLConfigurationReader
+  
+    def initialize(configuration)
+      raise "The REXMLConfigurationReader is incomplete at this time"
+      @configuration = configuration
+      load_files
+    end
+  
+    ##
+    # Iterates over the directory(s) defined in the properties["/config/plugin_path"]
+    # looking for subdirectories. When found, the plugin.xml file is read and the 
+    # identified file is "required" and the identified module has startup(bus,localbus) 
+    # called upon it.
+    #
+    def process_configuration_files(configuration)
+      plugin_element = nil
+      configuration.plugin_paths.split(";").each do |path|
+        Dir.foreach(path) do |file|
+          if file!=".." and file!="." and File.stat("#{path}/#{file}").directory?
+            filespec = "#{path}/#{file}/plugin.xml"
+            next unless File.exist?(filespec)
+            each_plugin_element(filespec) do |plugin_element| 
+              FreeBASE::Plugin.new(self, filespec, plugin_element)
+            end
+          elsif file[-4..-1]==".xml" and !File.stat("#{path}/#{file}").directory?
+            filespec = "#{path}/#{file}"
+            each_plugin_element(filespec) do |plugin_element| 
+              FreeBASE::Plugin.new(self, filespec, plugin_element)
+            end
+          end
+        end
+      end
+    end
+    ##
+    # Opens the supplied file and parse <plugin> elements
+    # yielding each to the supplied block.
+    #
+    # filespec:: [String] The file name to parse
+    # &block:: [String] The block to be yielded the REXML element
+    #
+    def each_plugin_element(filespec, &block)
+      file = File.new(filespec)
+      xml = REXML::Document.new file
+      file.close
+      plugin_element = xml.root
+      if plugin_element.name=="plugin"
+        yield plugin_element
+        return
+      else
+        yield plugin_element if plugin_element.attributes["name"] #register subsystem plugin
+        plugin_element.each_element("plugin") {|element| yield element}
+      end
+    end
+    
+    
+    def parse_xml(plugin_element)
+      if plugin_element.name=="subsystem"
+        @name = plugin_element.attributes["name"]
+        @version = "1.0"
+        @autoload=true
+        @startup_module = "FreeBASE::SubsystemPlugin"
+        @dependencies = {}
+        dependency = Dependency.new("LOADED", "start")
+        plugin_element.each_element("plugin") do |element|
+          dependency.add_plugin(element.attributes["name"], "*", "RUNNING")
+        end
+        @dependencies["LOADED"] = dependency
+      else
+        @name = plugin_element.attributes["name"]
+        @version = plugin_element.attributes["version"]
+        @autoload = plugin_element.attributes["autoload"]=="true" ? true : false
+        @require_file = plugin_element.elements["require"].text
+        @startup_module = plugin_element.elements["module"].text
+        if plugin_element.elements["resourcePath"]
+          @resource_path = plugin_element.elements["resourcePath"].text
+        end
+        if plugin_element.elements["properties"]
+          @properties_file = plugin_element.elements["properties"].text
+        end
+        @dependencies = {}
+        plugin_element.each_element("dependency") do |element|
+          dependency = Dependency.new(element.attributes["state"], element.attributes["action"])
+          element.each_element("when") do |pelement|
+            attr = pelement.attributes
+            dependency.add_plugin(attr["plugin"], attr["version"], attr["state"])
+          end
+          @dependencies[element.attributes["state"]] = dependency
+        end
+      end
+    end
+    
+  end
+  
+  # This represents the PropertiesReader and ConfigurationReader
+  # It is important that these be set either to YAML or REXML.
+  DefaultPropertiesReader = YAMLPropertiesReader
+  DefaultPropertiesReader.load_libraries
+  DefaultPropertiesReader.setup  
+  DefaultConfigurationReader = YAMLConfigurationReader
+ 
+end
+
+