redcar 0.3.1dev → 0.3.2dev

data/config/default.yaml

@@ -1,15 +0,0 @@
-#### Properties: Core configuration file - Version: 1.0
-properties: ~
-"|":
-  - config: ''
-    "|":
-      - log_file: "redcar.log"
-      - log_level: 0
-      - log_name: REDCAR
-      - plugin_path: "plugins"
-      - product_name: "Redcar"
-  - version: ''
-    "|":
-      - major: 0
-      - minor: 1
-      - release: 0

data/lib/freebase2/README.txt

@@ -1,47 +0,0 @@
-FreeBASE 2.0
-    by Daniel Lucraft, based on FreeBASE 1.0 by Rich Kilmer
-    http://www.daniellucraft.com/blog
-
-== DESCRIPTION:
-  
-
-
-== FEATURES/PROBLEMS:
-  
-
-== SYNOPSIS:
-
-  FIX (code sample 
-
-== REQUIREMENTS:
-
-* Ruby
-
-== INSTALL:
-
-* sudo gem install freebase2 (NOT YET)
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2007 FIX
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/freebase2/bin/default.yaml

@@ -1,15 +0,0 @@
-#### Properties: Core configuration file - Version: 1.0
-properties: ~
-"|":
-  - config: ''
-    "|":
-      - log_file: "freebase.log"
-      - log_level: 2
-      - log_name: FREEBASE
-      - plugin_path: "../plugins"
-      - product_name: "Freebase Example Application"
-  - version: ''
-    "|":
-      - major: 1
-      - minor: 2
-      - release: 0

data/lib/freebase2/bin/install.rb

@@ -1,42 +0,0 @@
-require 'rbconfig'
-require 'find'
-require 'ftools'
-
-Dir.chdir ".." if Dir.pwd =~ /bin.?$/
-
-include Config
-
-$srcdir = CONFIG["srcdir"]
-$version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
-$libdir = File.join(CONFIG["libdir"], "ruby", $version)
-$archdir = File.join($libdir, CONFIG["arch"])
-$site_libdir = $:.find {|x| x =~ /site_ruby$/}
-if !$site_libdir
-  $site_libdir = File.join($libdir, "site_ruby")
-elsif $site_libdir !~ Regexp.quote($version)
-  $site_libdir = File.join($site_libdir, $version)
-end
-
-def install_rb(srcdir = nil)
-  libdir = "lib"
-  libdir = File.join(srcdir, libdir) if srcdir
-  path = []
-  dir = []
-  Find.find(libdir) do |f|
-    next unless FileTest.file?(f)
-    next if (f = f[libdir.length+1..-1]) == nil
-    next if (/CVS$/ =~ File.dirname(f))
-    path.push f
-    dir |= [File.dirname(f)]
-  end
-  for f in dir
-    next if f == "."
-    next if f == "CVS"
-    File::makedirs(File.join($site_libdir, f))
-  end
-  for f in path
-    File::install(File.join("lib", f), File.join($site_libdir, f), 0644, true)
-  end
-end
-
-install_rb

data/lib/freebase2/bin/run.rb

@@ -1,48 +0,0 @@
-$FREEBASE_APPLICATION = "freebase"
-
-$:.unshift "../lib"
-
-require 'rbconfig'
-
-module FreeBASE
-  module Example
-    class Bootstrap
-      #version information
-      VERSION_MAJOR = 1
-      VERSION_MINOR = 2
-      VERSION_RELEASE = 0
-      
-      ##
-      # Start up the FreeBASE and block until shut down event is received
-      #
-      # dir:: [String] The directory which holds the properties.yaml and/or default.yaml
-      #
-      def self.startup(dir)
-      
-        require 'freebase/freebase'
-        
-        #verify the existence of the supplied directory
-        begin
-          files = Dir.entries(".")
-        rescue
-          raise "Could not locate directory '.'"
-        end
-        
-        #make sure that either freebase.yaml exists or default.yaml
-        unless files.include?("freebase.yaml")
-          raise "Could not locate default.yaml in #{dir}" unless files.include?("default.yaml")
-        end
-        
-        #This method will not return until FreeBASE is closed (shut down)
-        FreeBASE::Core.startup("freebase.yaml", "default.yaml")
-      end
-    end
-  end
-end
-
-if $0==__FILE__
-  baseDir = '.'
-  baseDir = ARGV[0] if ARGV.size > 0
-  FreeBASE::Example::Bootstrap.startup(baseDir)
-end
-

data/lib/freebase2/lib/freebase/configuration.rb

@@ -1,535 +0,0 @@
-# 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.
-#
-
-module FreeBASE
-
-  ##
-  # Main configuration control class.  Responsible for processing
-  # subsystem/plugins from supplied paths, resolving dependencies,
-  # and providing plugin lifecycle (load/start/stop/unload).
-  #
-  class Configuration
-    
-    attr_reader :plugins, :core, :plugin_paths
-    
-    ##
-    # Creates a configuration class from for the given FreeBASE core.
-    # Reads in the configuration files and resolves dependencies
-    #
-    # core:: [FreeBASE::Core] The core object.
-    # plugin_paths:: [String] A semicolon separated list of directories to search for plugins
-    #
-    def initialize(core, plugin_paths)
-      @core = core
-      @plugin_paths = plugin_paths
-      @plugins = {}
-      YAMLConfigurationReader.new(self)
-      resolve_dependencies
-    end
-    
-    ##
-    # Regsiters a config object (subsystem or plugin) with FreeBASE
-    #
-    # config:: [FreeBASE::SubsystemConfiguration | FreeBASE::PluginConfiguration] The configuration object
-    #
-    def register(config, base_path)
-      config.configuration = self
-      config.base_path = base_path
-      if File.absolute_path?(base_path)
-        config.full_base_path = base_path
-      else
-        config.full_base_path = File.expand_path(File.join($FR_CODEBASE, base_path))
-      end
-      if config.kind_of? SubsystemConfiguration
-        config.each_plugin {|plugin_config| register(plugin_config, base_path)}
-        return
-      end
-      @plugins[config.name] = config if config.autoload?
-    end
-    
-    ##
-    # Requires all the plugins based on the load list calculated by the dependency resolution
-    #
-    def require_plugins
-      num = 0
-      if @load_list.size == 0
-        puts "[FreeBASE] no plugins to require" if ARGV.include?("--debug-freebase")
-        exit
-      end
-      while num < @load_list.size
-        plugin = @load_list[num]
-        plugin.instance.require_files
-        num += 1
-      end
-    end
-    
-    ##
-    # Loads all the plugins based on the load list calculated by the dependency resolution
-    #
-    def load_plugins
-      num = 0
-      if @load_list.size == 0
-        puts "[FreeBASE] no plugins to load" if ARGV.include?("--debug-freebase")
-        exit
-      end
-      while num < @load_list.size
-        plugin = @load_list[num]
-        plugin.instance.load
-        if plugin.instance.state != LOADED
-          puts "[FreeBASE] failed to load: #{plugin.name}"
-          fail_load_dependencies(plugin)
-          fail_start_dependencies(plugin)
-        else
-          puts "[FreeBASE] loaded: #{plugin.name}" if ARGV.include?("--debug-freebase")
-          num += 1
-        end
-      end
-    end
-    
-    ##
-    # Starts all the plugins based on the start list calculated by the dependency resolution
-    #
-    def start_plugins
-      num = 0
-      while num < @start_list.size
-        plugin = @start_list[num]
-        plugin.instance.start
-        if plugin.instance.state != RUNNING
-          puts "[FreeBASE] failed to start: #{plugin.name}"
-          fail_start_dependencies(plugin)
-        else
-         puts "[FreeBASE] started: #{plugin.name}" if ARGV.include?("--debug-freebase")
-        num += 1
-        end
-      end
-    end
-    
-    ##
-    # Stops all the plugins based on reversing the start list calculated by the dependency resolution
-    #
-    def stop_plugins
-      @start_list.reverse.each do |plugin|
-        plugin.instance.stop
-      end
-    end
-    
-    ##
-    # Unloads all the plugins based on by reversing the load list calculated by the dependency resolution
-    #
-    def unload_plugins
-      @load_list.reverse.each do |plugin|
-        plugin.instance.unload
-      end
-    end
-    
-    private
-    
-    def fail_load_dependencies(plugin)
-      @load_list.delete(plugin)
-      plugin.rev_load_graph.each { |other| fail_load_dependencies(other) }
-    end
-    
-    def fail_start_dependencies(plugin)
-      @start_list.delete(plugin)
-      plugin.rev_start_graph.each { |other| fail_start_dependencies(other) }
-    end
-    
-    def resolve_dependencies
-      # graph dependencies
-      @plugins.each_value do |plugin|
-        plugin.build_graph
-      end
-      # compute load and start levels
-      @plugins.each_value do |plugin|
-        plugin.compute_levels
-      end
-      # build load list
-      @load_list = @plugins.values
-      @load_list.sort! do |a, b|
-        a.load_level<=>b.load_level
-      end
-      # build start list
-      @start_list = @plugins.values
-      @start_list.sort! do |a, b|
-        a.start_level<=>b.start_level
-      end
-    end
-    
-    def debug
-     @plugins.each do |name, plugin|
-        puts "Plugin: #{name} Load Level:  #{plugin.load_level} Dep: #{plugin.fwd_load_graph.collect {|p| p.name}.join(', ')}"
-      end
-      puts "_"*30
-      @load_list.each {|plugin| puts "#{plugin.load_level}: #{plugin.name}"}
-      puts "_"*30
-      puts "_"*30
-      @plugins.each do |name, plugin|
-        puts "Plugin: #{name} Start Level: #{plugin.start_level} Dep: #{plugin.fwd_start_graph.collect {|p| p.name}.join(', ')}"
-      end
-      puts "_"*30
-      @start_list.each {|plugin| puts "#{plugin.start_level}: #{plugin.name}"}
-      exit
-    end
-    
-  end
-  
-  ##
-  # Represents a subsystem (set of plugins) in FreeBASE.  It creates
-  # a plugin named the subsystem name which is dependent on all plugins
-  # in the subsystem.  This allows another plugin to be dependent on
-  # all the plugins in the subsystem by simply being dependent on the
-  # plugin named after the subsystem
-  #
-  class SubsystemConfiguration
-    attr_accessor :name, :version, :base_path, :full_base_path
-    attr_reader :plugins
-    attr_reader :configuration
-    
-    ##
-    # Orders the properties to export when this object is serialized
-    # to YAML
-    #
-    # return:: [Array] List of properties to export...used by YAML
-    #
-    def to_yaml_properties
-      ['@name', '@version', '@plugins']
-    end
-    
-    ##
-    # Constructs a SubsystemConfiguration object.  May optionally
-    # supply block with yielded instance of 'self' to set properties.
-    #
-    def initialize
-      @plugins = []
-      yield self if block_given?
-    end
-    
-    ##
-    # Set the configuration instance.  Also builds the plugin which represents
-    # the subsystem.  This should be called only after all plugins configurations 
-    # have beed processed and added to this subsystem.
-    #
-    # configuration:: [FreeBASE::Configuration] The FreeBASE configuration manager
-    #
-    def configuration=(configuration)
-      @configuration = configuration
-      each_plugin {|plugin| plugin.configuration = configuration}
-      #add plugin to represent the subsystem itself
-      add_plugin do |plugin|
-        plugin.name = @name
-        plugin.version = @version
-        plugin.require_path = nil #"freebase/plugin"
-        plugin.startup_module = "FreeBASE::SubsystemPlugin"
-        plugin.autoload = true
-        @plugins.each do |other|
-          plugin.add_load_dependency(other.name)
-        end
-        @plugins.each do |other|
-          plugin.add_start_dependency(other.name)
-        end
-      end
-    end
-    
-    ##
-    # Returns a newly created plugin accepting an optional block
-    # which can be used to set attributes of the plugin
-    #
-    # &block:: [Block] Accepts the yielded plugin as the parameter
-    def add_plugin(&block)
-      plugin = PluginConfiguration.new(&block)
-      plugin.configuration = @configuration
-      @plugins << plugin
-      plugin
-    end
-    
-    ##
-    # Iterates over the list of available plugins yielding each one
-    #
-    def each_plugin
-      @plugins.each {|plugin| yield plugin}
-    end
-    
-  end
-  
-  ##
-  # This class holds the metadata about a plugin.  It is created
-  # by a Reader (see reader.rb) from either an XML file or a YAML
-  # load operation.
-  #
-  class PluginConfiguration
-  
-    ##
-    # Raised if there is a circular dependency in plugins during load/start
-    # holds a reversing list of plugins to be able to show the cycle.
-    #
-    class CircularDependency < RuntimeError
-      attr_reader :plugin_list
-      ##
-      # Constructs an exception with the supplied elements
-      #
-      # dep_type:: [String] Ether "load" or "start"
-      # start_plugin:: [FreeBASE::PluginConfiguration] The plugin that the cycle was caught in
-      def initialize(dep_type, start_plugin)
-        @dep_type = dep_type.capitalize
-        @plugin_list = [start_plugin]
-      end
-      
-      ##
-      # Outputs the cycle:
-      #   PluginA -> PluginB -> PluginC -> PluginA
-      #
-      def to_s
-        cycle = (@plugin_list.collect {|plugin| plugin.name}).reverse.join("->")
-        "\n#{@dep_type} Circular Plugin Dependency: #{cycle}"
-      end
-    end
-    
-    attr_accessor(:name, :version, :require_path, :dependencies_path,
-                  :properties_path, :startup_module, 
-                  :resource_path, :base_path, 
-                  :full_base_path, 
-                  :description, :author, :tests, :test_module)
-    attr_writer :autoload
-    attr_reader :configuration
-    attr_reader :fwd_load_graph, :fwd_start_graph
-    attr_reader :rev_load_graph, :rev_start_graph
-    attr_reader :load_level, :start_level
-    
-    def dependencies_met
-      if @dependencies_met == nil
-        true
-      else
-        @dependencies_met
-      end
-    end
-
-    alias :dependencies_met? :dependencies_met
-    
-    ##
-    # Contructs a plugin configuration.  Yields instance of self for initializing instance data.
-    #
-    def initialize
-      yield self if block_given?
-      @dependencies_met = true
-    end
-    
-    ##
-    # Retrieve the base path in the in the user dir (USERPROFILE or HOME)
-    #
-    def base_user_path
-      filename = DefaultPropertiesReader.user_filename(File.join(@base_path,"foo.bar"))
-      unless @base_user_path
-        if filename
-          require 'fileutils'
-          FileUtils.mkdir_p(File.dirname(filename))
-          @base_user_path = File.dirname(filename)
-        end
-      end
-      @base_user_path
-    end
-    
-    ##
-    # Retrieve the local user file (in USERPROFILE or HOME) of the supplied filespec.
-    # This method is usefull if a plugin needs to create a file
-    #
-    def user_filename(filespec, ensure_dir=false)
-      filename = DefaultPropertiesReader.user_filename(filespec)
-      if ensure_dir && filename
-        require 'fileutils'
-        FileUtils.mkdir_p(File.dirname(filename))
-      end
-    end
-    
-    ##
-    # Orders the properties to export when this object is serialized
-    # to YAML
-    #
-    # return:: [Array] List of properties to export...used by YAML
-    #
-    def to_yaml_properties
-      ['@name', '@version', '@autoload', '@require_path', 
-       '@startup_module', '@properties_path', 
-       '@resource_path', '@load_dependencies', '@start_dependencies']
-    end
-    
-    ##
-    # Gets (and possibly builds if first time called) the FreeBASE::Plugin object
-    #
-    # return:: [FreeBASE::Plugin] The plugin controller for this configuration
-    #
-    def instance
-      unless @plugin_instance
-        @plugin_instance = FreeBASE::Plugin.new(@configuration.core, self)
-      end
-      @plugin_instance
-    end
-    
-    ##
-    # Builds a graph of dependencies (both forward and reverse) which is used to 
-    # detect cycles and block loading/starting of plugins whose dependent plugin
-    # fails
-    #
-    def build_graph
-      each_load_dependency do |other, version|
-        other_plugin = @configuration.plugins[other]
-        unless other_plugin
-          puts "#{@name} has a load dependency not found: #{other}"
-          @dependencies_met = false
-          return false
-        end
-        @fwd_load_graph << other_plugin
-        other_plugin.rev_load_graph << self
-      end
-      each_start_dependency do |other, version|
-        other_plugin = @configuration.plugins[other]
-        unless other_plugin
-          puts "#{@name} has a start dependency not found: #{other}"
-          @dependencies_met = false
-          return false
-        end
-        return false unless other_plugin
-        @fwd_start_graph << other_plugin
-        other_plugin.rev_start_graph << self
-      end
-      return true
-    end
-    
-    ##
-    # Computes the load level and start level for this plugin configuration
-    #
-    def compute_levels
-      get_load_level
-      get_start_level
-    end
-    
-    ##
-    # Returns the load level for this plugin configuration.  This will always
-    # be one higher than the highest level plugin which this plugin is dependent
-    # on.  This method may raise a CircularDependency exception if on is detected.
-    # 
-    # return:: [Integer] The load level
-    #
-    def get_load_level
-      raise (CircularDependency.new("Load", self)) if @computing_levels
-      return @load_level if @load_level
-      @computing_levels = true
-      @load_level = 0
-      @fwd_load_graph.each do |other|
-        begin
-          olevel = other.get_load_level + 1
-        rescue CircularDependency => cycle
-          cycle.plugin_list << self
-          raise
-        end
-        @load_level = olevel unless @load_level > olevel
-      end
-      @computing_levels = false
-      return @load_level
-    end
-    
-    ##
-    # Returns the start level for this plugin configuration.  This will always
-    # be one higher than the highest level plugin which this plugin is dependent
-    # on.  This method may raise a CircularDependency exception if on is detected.
-    # 
-    # return:: [Integer] The start level
-    #
-    def get_start_level
-      raise (CircularDependency.new("Start", self)) if @computing_levels
-      return @start_level if @start_level
-      @computing_levels = true
-      @start_level = 0
-      @fwd_start_graph.each do |other|
-        begin
-          olevel = other.get_start_level + 1
-        rescue CircularDependency => cycle
-          cycle.plugin_list << self
-          raise
-        end
-        @start_level = olevel if @start_level < olevel
-      end
-      @computing_levels = false
-      return @start_level
-    end
-    
-    ##
-    # Sets the configuration controller for this plugin config.
-    #
-    # configuration:: [FreeBASE::Configuration] The configuration controller instance
-    #
-    def configuration=(configuration)
-      @fwd_load_graph = []
-      @fwd_start_graph = []
-      @rev_load_graph = []
-      @rev_start_graph = []
-      @configuration = configuration
-    end
-    
-    ##
-    # Returns whether this plugin should automatically load and start
-    #
-    # return:: [Boolean] True if this plugin should load and start, otherwise false
-    #
-    def autoload?
-      @autoload
-    end
-    
-    ##
-    # Returns instance of self
-    #
-    def each_plugin
-      yield self
-    end
-    
-    ##
-    # Add a load dependency for this plugin
-    #
-    # plugin:: [String] The plugin name that this plugin is dependent on to load
-    # version:: [String="*"] The version of the plugin that this plugin is dependent on (* for any)
-    #
-    def add_load_dependency(plugin, version="*")
-      @load_dependencies ||= {}
-      @load_dependencies[plugin]=version
-    end
-    
-    ##
-    # Add a start dependency for this plugin
-    #
-    # plugin:: [String] The plugin name that this plugin is dependent on to start
-    # version:: [String="*"] The version of the plugin that this plugin is dependent on (* for any)
-    #
-    def add_start_dependency(plugin, version="*")
-      @start_dependencies ||= {}
-      @start_dependencies[plugin]=version
-    end
-    
-    ##
-    # Iterates over each load dependency yielding a |plugin, version| for each iteration.
-    #
-    def each_load_dependency(&block)
-      return unless @load_dependencies
-      @load_dependencies.each(&block)
-    end
-    
-    ##
-    # Iterates over each start dependency yielding a |plugin, version| for each iteration.
-    #
-    def each_start_dependency(&block)
-      return unless @start_dependencies
-      @start_dependencies.each(&block)
-    end
-  end
-end
-
-