plugin_manager 1.1 → 1.2

data/README.md

@@ -54,6 +54,9 @@ The code in the appropriate plugins will be loaded and you will then have availa
     # plugins that raised exceptions while being loaded
     manager.plugins_with_errors
 
+NB. There is a BIG difference between this and say, Rubygems, in that plugin_manager will ONLY EVER
+LOAD THE MOST RECENT VERSION OF A PLUGIN. Older versions essentially DON'T EXIST from the point of view
+of the plugin_manager.
 
 License
 =======

data/Rakefile

@@ -0,0 +1,22 @@
+require "rubygems"
+require "rake/rdoctask"
+
+require "spec"
+require "spec/rake/spectask"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = %w(--format specdoc --colour)
+  t.libs = ["spec"]
+end
+
+task :default => ["spec"]
+
+# Generate documentation
+Rake::RDocTask.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+end

data/lib/plugin_manager.rb

@@ -6,75 +6,199 @@ require 'plugin_manager/plugin_definition'
 require 'plugin_manager/definition_builder'
 
 class PluginManager
-  attr_reader :unreadable_definitions, :plugins_with_errors, :loaded_plugins, :unloaded_plugins
+  attr_reader :unreadable_definitions, :plugins_with_errors, :loaded_plugins, :unloaded_plugins, :output
 
-  def initialize
-    @unloaded_plugins = []
-    @loaded_plugins = []
+  class << self
+    attr_accessor :current
+  end
+  
+  def initialize(output = STDOUT)
+    @plugins                = []
+    @unloaded_plugins       = []
+    @loaded_plugins         = []
     @unreadable_definitions = []
-    @plugins_with_errors = []
+    @plugins_with_errors    = []
+    @output = output
   end
 
+  def on_load(&block)
+    @load_observer = block
+  end
+  
   def plugins
-    @unloaded_plugins + @loaded_plugins
+    @plugins
   end
+  
+  def plugin_objects
+    @loaded_plugins.map {|definition| definition.object}
+  end
+  
+  def objects_implementing(method_name)
+    plugin_objects.select {|obj| obj.respond_to?(method_name) }
+  end
+
+  class Dependency
+    attr_reader :required_name
+    attr_reader :required_version
+    
+    def initialize(plugin_manager, required_name, required_version)
+      @plugin_manager = plugin_manager
+      @required_name = required_name
+      @required_version = required_version
+    end
+    
+    def satisfied?
+      if loaded_plugin = @plugin_manager.loaded_plugins.detect {|pl| pl.name == required_name }
+        PluginManager.compare_version(required_version, loaded_plugin.version)
+      end
+    end
+    
+    def inspect
+      "dep(#{required_name} #{required_version})"
+    end
+  end
+  
+  def add_gem_plugin_source
+    all_gem_names           = Gem::SourceIndex.from_installed_gems.map {|n, _| n}
+    redcar_plugin_gem_names = all_gem_names.select {|n| n =~ /^redcar-/}
+    
+    definition_files = redcar_plugin_gem_names.map do |gem_name|
+      [gem_name, ENV["GEM_HOME"] + "/gems/" + gem_name + "/plugin.rb"]
+    end
+
+    definition_files = definition_files.select do |name, definition_file|
+      File.exist?(definition_file)
+    end
+    
+    if definition_files.any?
+      gem_names = definition_files.map {|n, _| n }
+      @output.puts "[PluginManager] found gem plugins #{gem_names.inspect}" if ENV["PLUGIN_DEBUG"]
+    end
+    
 
+    add_definition_files(definition_files.map {|_, f| f})
+  end
+  
   def add_plugin_source(directory)
     definition_files = Dir[File.join(File.expand_path(directory), "*", "plugin.rb")]
     definition_files.reject! {|f| plugins.any? {|pl| pl.definition_file == File.expand_path(f) } }
-    new_definitions = 
-      definition_files.map do |file|
-        begin
-          definition = instance_eval(File.read(file))
-          definition.definition_file = File.expand_path(file)
-          definition
-        rescue Object => e
-          puts "Unreadable plugin definition: #{file}"
-          puts "  " + e.message
-          puts e.backtrace.map {|l| "  " + l }
-          @unreadable_definitions << file
-          nil
+    
+    add_definition_files(definition_files)
+  end
+  
+  def add_definition_files(definition_files)
+    definition_files.each do |file|
+      begin
+        PluginManager.current = self
+        definition = instance_eval(File.read(file))
+        PluginManager.current = nil
+        definition.definition_file = File.expand_path(file)
+        if already_with_that_name = @plugins.detect {|pl| pl.name == definition.name }
+          if already_with_that_name.version.to_f < definition.version.to_f
+            @unloaded_plugins.delete(already_with_that_name)
+            @plugins.delete(already_with_that_name)
+            @unloaded_plugins << definition
+            @plugins << definition
+          end
+        else
+          @unloaded_plugins << definition
+          @plugins << definition
         end
-      end.compact.sort_by {|p| p.name.downcase }
-    @unloaded_plugins += new_definitions
+      rescue Object => e
+        @output.puts "Unreadable plugin definition: #{file}"
+        @output.puts "  " + e.message
+        @output.puts e.backtrace.map {|l| "  " + l }
+        @unreadable_definitions << file
+        nil
+      end
+    end
+    
+    @plugins = @plugins.sort_by {|pl| pl.name }
+    @unloaded_plugins = @unloaded_plugins.sort_by {|pl| pl.name }
   end
   
-  def load
-    previous_length = @unloaded_plugins.length + 1
-    while previous_length > @unloaded_plugins.length
-      previous_length = @unloaded_plugins.length
-      if plugin = next_to_load
-        begin
-          puts "[PluginManager] loading #{plugin.name}" if ENV["PLUGIN_DEBUG"]
-          plugin.load
-          @loaded_plugins << plugin
-        rescue Object => e
-          puts "Error loading plugin: #{plugin.inspect}"
-          puts "  " + e.message
-          puts e.backtrace.map {|l| "  " + l }
-          @plugins_with_errors << plugin
+  def load(*plugin_names)
+    if plugin_names.empty?
+      return load_maximal
+    else
+      target_dependencies = plugin_names.map do |n| 
+        unless result = latest_version_by_name(n) 
+          raise "can't find plugin named #{n}"
         end
-        @unloaded_plugins.delete(plugin)
+        Dependency.new(self, n, ">0")
+      end
+    end
+    remaining_to_load = expand_dependencies(target_dependencies)
+    while remaining_to_load.length > 0
+      previous_length = remaining_to_load.length
+      if plugin = next_to_load(remaining_to_load)
+        load_plugin(plugin)
+        remaining_to_load = remaining_to_load.reject {|dep| dep.required_name == plugin.name }
+      else
+        puts "no plugin to load from #{remaining_to_load.inspect}"
+        return
       end
+      new_length = remaining_to_load.length
     end
   end
   
-  private
+  def latest_version_by_name(name)
+    @plugins.select {|pl| pl.name == name }.sort_by {|pl| pl.version }.last
+  end
   
-  def next_to_load
-    # this ordering ensures we try the most recent version of a plugin first
-    remaining_plugins = @unloaded_plugins.sort_by {|pl| pl.version }.reverse
-    
-    remaining_plugins.detect do |d|
-      next if @loaded_plugins.map {|pl| pl.name }.include?(d.name)
-      (d.dependencies||[]).all? do |dep|
-        req_name, req_ver = *dep
-        @loaded_plugins.detect do |d1| 
-          d1.name == req_name and 
-            PluginManager.compare_version(req_ver, d1.version)
+  def load_plugin(plugin)
+    begin
+      @output.puts "[PluginManager] loading #{plugin.name}" if ENV["PLUGIN_DEBUG"]
+      plugin.load
+      if @load_observer
+        @load_observer.call(plugin)
+      end
+      @loaded_plugins << plugin
+    rescue Object => e
+      @output.puts "Error loading plugin: #{plugin.inspect}"
+      @output.puts "  " + e.message
+      @output.puts e.backtrace.map {|l| "  " + l }
+      @plugins_with_errors << plugin
+    end
+    @unloaded_plugins.delete(plugin)
+  end
+  
+  def load_maximal
+    while ready_plugin = @unloaded_plugins.detect {|pl| pl.dependencies.all? {|dep| dep.satisfied? }}
+      load_plugin(ready_plugin)
+    end
+    @load_observer = nil # After loading all possible plugins, remove the load observer
+  end
+  
+  def expand_dependencies(dependency_array)
+    previous_length = dependency_array.length
+    new_dependency_array = dependency_array.map do |dep|
+      if pl = latest_version_by_name(dep.required_name)
+        [dep, pl.dependencies]
+      else
+        dep
+      end
+    end.flatten.uniq
+    if new_dependency_array.length > previous_length
+      expand_dependencies(new_dependency_array)
+    else
+      new_dependency_array
+    end
+  end
+
+  def next_to_load(dependency_array)
+    hash = Hash.new {|h,k| h[k] = []}
+    dependency_array.each {|dep| hash[dep.required_name] << dep.required_version}
+    hash.each do |name, version_requirements|
+      if candidate_for_loading = unloaded_plugins.detect {|pl| pl.name == name}
+        all_requirements_met = version_requirements.all? do |version_requirement|
+          PluginManager.compare_version(version_requirement, candidate_for_loading.version)
         end
+        all_candidate_deps_met = candidate_for_loading.dependencies.all? {|dep| dep.satisfied?}
+        return candidate_for_loading if all_requirements_met and all_candidate_deps_met
       end
     end
+    nil
   end
   
   def self.compare_version(required, got)
@@ -98,7 +222,7 @@ class PluginManager
           md[2] != got
         end
       else
-        puts "don't recognize version string: #{required.inspect}"
+        @output.puts "don't recognize version string: #{required.inspect}"
       end
     end
   end

data/lib/plugin_manager/definition_builder.rb

@@ -27,10 +27,28 @@ class PluginManager
       @definition.file = values
     end
     
+    def install(*args)
+      if args.length == 1
+        if Hash === args.first
+          hash = args.first
+        else
+          hash = { args.first => File.basename(args.first) }
+        end
+      elsif args.length == 2
+        prefix = args.first
+        if Hash === args[1]
+          hash   = Hash[args[1].map {|k, v| [prefix + k, v]}]
+        elsif Array === args[1]
+          hash = Hash[args[1].map {|path| [prefix + path, File.basename(path) ] } ]
+        end
+      end
+      @definition.resources.merge!(hash)
+    end
+    
     def dependencies(*deps)
       @definition.dependencies ||= []
       deps.each_slice(2) do |name, ver|
-        @definition.dependencies << [name, ver]
+        @definition.dependencies << PluginManager::Dependency.new(PluginManager.current, name, ver)
       end
     end
   end

data/lib/plugin_manager/plugin_definition.rb

@@ -5,22 +5,35 @@ class PluginManager
                   :version,
                   :object_string,
                   :file,
-                  :dependencies,
-                  :definition_file
+                  :definition_file,
+                  :resources
                   
     def inspect1              
-      "<Plugin #{name} #{version} depends:[#{(dependencies||[]).map{|dep| dep.join("")}.join(", ")}] #{required_files.length} files>"
+      "<Plugin #{name} #{version} depends:#{dependencies.inspect} #{required_files.length} files>"
     end
     
     def inspect
       inspect1
     end
     
+    def resources
+      @resources ||= {}
+    end
+    
     def required_files
       @required_files ||= []
     end
     
+    def dependencies
+      @dependencies ||= []
+    end
+    
+    def load_time
+      @load_time
+    end
+    
     def load
+      s = Time.now
       required_files.each {|file| $".delete(file) }
       load_file = File.expand_path(File.join(File.dirname(definition_file), file))
       $:.unshift(File.dirname(load_file))
@@ -31,6 +44,7 @@ class PluginManager
       if object.respond_to?(:loaded)
         object.loaded
       end
+      @load_time = Time.now - s
     end
     
     def object

metadata

@@ -1,67 +1,70 @@
 --- !ruby/object:Gem::Specification 
 name: plugin_manager
 version: !ruby/object:Gem::Version 
-  version: "1.1"
+  prerelease: 
+  version: "1.2"
 platform: ruby
 authors: 
-- Daniel Lucraft
+  - Daniel Lucraft
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-01-17 00:00:00 +00:00
+date: 2011-06-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id001
 description: 
 email: dan@fluentradical.com
-executables: 
-- plugin_manager
+executables: []
+
 extensions: []
 
 extra_rdoc_files: 
-- README.md
+  - README.md
 files: 
-- README.md
-- lib/plugin_manager/definition_builder.rb
-- lib/plugin_manager/plugin.rb
-- lib/plugin_manager/plugin_definition.rb
-- lib/plugin_manager.rb
+  - README.md
+  - Rakefile
+  - lib/plugin_manager.rb
+  - lib/plugin_manager/definition_builder.rb
+  - lib/plugin_manager/plugin.rb
+  - lib/plugin_manager/plugin_definition.rb
 has_rdoc: true
 homepage: http://github.com/danlucraft/plugin_manager
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --main
-- README.md
+  - --main
+  - README.md
 require_paths: 
-- lib
+  - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.5.1
 signing_key: 
 specification_version: 3
 summary: A Ruby plugin loader

data/bin/plugin_manager

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.join(File.dirname(__FILE__), "..", "lib", "plugin_manager")
-