plugems 1.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Revolution Health Group LLC. All rights reserved.
+
+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/config/manifest.yml

@@ -0,0 +1,5 @@
+:version: [1, 1]  
+:name: 'plugems'
+:description: 'Dependency-management framework built on top of Ruby On Rails'
+:dependencies: []
+

data/init.rb

@@ -0,0 +1 @@
+require 'plugems'

data/lib/plugems.rb

@@ -0,0 +1,44 @@
+# Rails 1.1.16 is not very extensible in how it loads rake tasks.
+# There is a file called tasks/rails.rb, required from the default RAILS_ROOT/Rakefile,
+# that has 3 lines of Dir['foo'].each {|a| load a}, which is not very extensible
+# Therefore, plugems unshifts the current lib directory in order to include a plugem
+# copy of tasks/rails.rb.
+$:.unshift File.dirname(__FILE__)
+
+if defined?(RAILS_ROOT)
+  require 'plugems/loader'
+
+  module Rails
+  	class Initializer
+
+  		def load_plugins_with_plugems
+  			Plugems::Loader.load(configuration)
+  			load_plugins_without_plugems
+  		end
+
+  		# TODO replace with alias_method_chain on Rails 1.2
+  		# alias_method_chain :load_plugins, :plugems
+  		alias_method :load_plugins_without_plugems, :load_plugins
+  		alias_method :load_plugins, :load_plugins_with_plugems
+  	end
+  end
+end
+
+module Gem
+  
+  class << self
+  
+    def activate_plugin_or_gem(gem, autorequire, *version_requirements)
+      if Plugems::Loader.plugin?(gem)
+  			Plugems::Loader.load_as_plugin(gem)
+  		else
+  			activate_gem(gem, autorequire, *version_requirements)
+  		end
+    end
+  
+    alias_method :activate_gem, :activate
+    alias_method :activate, :activate_plugin_or_gem
+
+  end
+
+end

data/lib/plugems/loader.rb

@@ -0,0 +1,153 @@
+require 'plugems/manifest'
+require 'plugems/tasks/loader'
+
+# load monkey patch for finding views in plugins + gems too
+require 'plugems/plugem_view_support.rb'
+
+module Plugems
+	class Loader
+
+    module ClassMethods
+      
+  		def load(configuration)
+  			# TODO find a way to get the plugin_paths defined in the Rails::Initializer block, if any
+  			#@@configuration = configuration
+			@@loaded_plugems = {} # hash of all loaded plugems, to prevent loading duplicates
+			
+  			manifest = Plugems::Manifest.load("#{RAILS_ROOT}/config/manifest.yml")
+  			load_plugems(manifest)
+  			set_dependencies_loaded_flag
+  		end
+
+  		def gem_rake_tasks
+  			(@@gem_rake_tasks ||= []).flatten.uniq
+  		end
+
+      def gem_views
+        (@@gem_views ||= []).flatten.uniq
+      end
+
+      def plugin_views
+        plugin_lib_paths.collect do |plugin_path|
+           Dir["#{plugin_path}/views/**/*.*"]
+        end.flatten.uniq
+      end
+      
+      def plugin?(name)
+        (path = plugin_path(name)) && File.directory?(path)
+			end
+		  
+  		def load_as_plugin(name)
+  		  path = plugin_path(name)
+  		  plugin_lib = File.join(path, "lib")
+  			$: << plugin_lib if File.exist?(plugin_lib)
+        process_plugin_manifest(path)
+  		end
+  		
+  		private 
+
+  		def plugin_lib_paths
+  			# TODO determine if the configuration object is already configured by this point
+  		  Rails::Configuration.new.plugin_paths.collect do |plugin_path|
+  				# Cant use Dir["foo/**/lib"] because symlinks are not followed with Dir
+  				Dir["#{plugin_path}/*"].collect { |plugin_lib| plugin_lib}
+  			end.flatten.uniq
+  		end
+
+  		def load_plugems(manifest)
+  			# after loading the gem specific dependencies require 
+  			# each file picking up gems and plugins.  This is loaded outside the above loop
+  			# incase of a dependency cycle...
+  			manifest.dependencies.each do |name, version|
+  				load_plugem(name, version || ">= 0.0.0")
+  			end
+  		end
+
+  		def load_plugem(name, version)
+			return if @@loaded_plugems.include?(name)
+			debug "Loading #{name}..."
+			if plugin?(name)
+  				load_as_plugin(name)
+  			else
+  				load_as_gem(name,version)
+  			end
+			debug "Loaded #{name}!"
+			@@loaded_plugems[name] = true
+  		end
+
+		def plugin_path(gem_or_plugin)
+			name = gem_or_plugin.respond_to?(:name) ? gem_or_plugin.name : gem_or_plugin 
+			plugin_lib_paths.grep(/\/#{name}$/).first
+		end
+		  
+		  def process_plugin_manifest(path)
+		    plugin_manifest_file = File.join(path, "config", "manifest.yml")
+  			if File.exists?(plugin_manifest_file)
+  			  plugin_manifest = Plugems::Manifest.load(plugin_manifest_file)
+  			  load_plugems(plugin_manifest)
+  			end
+			end
+  		  
+  		def load_as_gem(name, version)
+  		  
+  				begin
+
+  					require_gem name, version
+
+  					path = gem_path(name)
+  					append_rake_tasks!(path)
+  					append_gem_views!(path)
+
+  					debug "#{name} - Found: (#{loaded_version(name)})"
+  				rescue Gem::LoadError, Gem::Exception => gem_load_error
+  					error "#{gem_load_error}"
+  					error "#{name} - Searching: (#{version}), but found: (#{loaded_version(name)})"
+  					error "use BOOT_DEBUG=true to show more information."
+  					exit(1)
+  				rescue Exception => error
+  					error "#{error}"
+  					error.backtrace.each do |stacktrace|
+  					   error "    #{stacktrace}"
+  					end
+  					exit(1)
+  				end
+
+  		end
+
+  		def loaded_version(gem_name)
+  			gem_path(gem_name).split('/').grep(/#{gem_name}/).first[/[\d\.]+$/] rescue "Not Found"
+  		end
+
+  		def gem_path(gem_name)
+  			File.dirname($:.grep(%r{/gems/#{gem_name}-\d}).first)
+  		end
+
+  		def debug(msg)
+  			puts "[Plugems Debug]: #{msg}" if ENV['BOOT_DEBUG']
+  		end
+
+  		def error(msg)
+  			puts "[Plugems Error]: #{msg}"
+  		end
+
+  		def set_dependencies_loaded_flag
+  			# TODO: fix rhg_configuration to use Rails::Initializer.all_dependencies_loaded?
+  			Object.const_set('DEPENDENCIES_LOADED', true) unless defined?(DEPENDENCIES_LOADED)
+  		end
+
+  		def append_gem_views!(path)
+  			views = Dir["#{path}/views/**/*.*"]
+  			(@@gem_views ||= []) << views unless views.blank?
+  		end
+
+  		def append_rake_tasks!(path)
+  			tasks = Dir["#{path}/tasks/**/*.rake"].reject {|tsk| tsk=~/bootstrap|rails/}
+  			(@@gem_rake_tasks ||= []) << tasks unless tasks.blank?
+  		end
+		
+	  end
+	  
+		extend ClassMethods
+		
+	end
+end

data/lib/plugems/manifest.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+require 'erb'
+module Plugems
+	class Manifest
+
+		attr_accessor :manifest
+
+    [:name, :version, :description, :author, :executables].each do |property|
+      define_method(property) { manifest[property] }
+    end
+    
+		def initialize(file_name = nil)
+			begin
+				@manifest = load_file(file_name || self.class.manifest_file)
+			rescue Exception => e
+				puts "#{e}. Manifest file is not set? (via Plugems::Manifest.manifest_file =)"
+				puts e
+			end
+		end
+
+		def dependencies
+			manifest[:dependencies] || []
+		end
+
+		module ClassMethods
+		  
+		  @@manifest_file = nil
+			
+			def manifest_file
+				 @@manifest_file || default_manifest_file
+			end
+
+			def load(file_name)
+				new(file_name)
+			end
+
+			def default_manifest_file
+			  "#{RAILS_ROOT}/config/manifest.yml"
+			end
+
+			def manifest_file=(file)
+			   @@manifest_file = file
+		  end
+		  
+		end
+
+		extend ClassMethods
+		
+	private
+		  
+		  def load_file(file)
+		    YAML.load(ERB.new(IO.read(file)).result)
+	    end
+
+	end
+
+end

data/lib/plugems/plugem_view_support.rb

@@ -0,0 +1,75 @@
+class TemplateCache
+  
+  @@cache = {}
+  @@caching = true
+  
+  def self.cache
+    @@caching ? @@cache : {}
+  end
+  
+  def self.caching=(arg)
+    @@caching = arg
+  end
+  
+end
+
+# Plugems requires that views be loaded from gems defined in application manifest
+module ActionView
+	class Base
+		def full_template_path(template_path, extension)
+      TemplateCache.cache[ [template_path, extension] ] ||= lookup_full_template_path(template_path, extension)
+		end
+
+    def lookup_full_template_path(template_path, extension)
+      default_template = "#{@base_path}/#{template_path}.#{extension}"
+			return default_template if File.exist?(default_template)
+			
+			plugin_views = self.class.plugin_template("#{template_path}.#{extension}")
+			return plugin_views.first || default_template
+		end
+		
+		# This is cached, and maybe should not be cached in development mode. 
+		def self.plugin_templates
+      # Note: This does support symlinks (top-level) vendor/plugins/acts_as_funky_chicken, 
+			# but not vendor/plugins/acts/acts_as_funky_bacon
+			(Plugems::Loader.gem_views + Plugems::Loader.plugin_views).flatten.uniq
+		end
+
+    def self.plugin_template(file_name)
+			 plugin_templates.select {|dir| dir =~ /#{file_name}/ }
+	  end
+
+		def self.plugin_layouts
+			 plugin_templates.select {|dir| dir =~ /views\/layouts/ }
+		end
+	end
+end
+
+# action_pack/lib/action_controller/layout.rb
+module ActionController 
+	module Layout 
+		module ClassMethods
+
+			# Allow layouts to also exist in plugems
+		  def layout_list
+			  TemplateCache.cache[:layout_list_cache] ||= Dir.glob("#{template_root}/layouts/**/*") + ActionView::Base.plugin_layouts
+		  end
+		end
+
+		private
+		def layout_directory?(layout_name)
+			TemplateCache.cache[layout_name] ||= begin
+		   	template_path = File.join(self.class.view_root, 'layouts', layout_name) 
+		  	dirname = File.dirname(template_path)
+
+				# if the layout requested was not found in the application view root, look in plugem view paths
+			  unless File.directory? dirname
+				  plugin_layout_list = ActionView::Base.plugin_template("\/views\/layouts\/#{layout_name}.*")
+				  dirname = File.dirname(plugin_layout_list.first) if plugin_layout_list.first
+			  end
+
+			  self.class.send(:layout_directory_exists_cache)[dirname]
+			end
+		end
+	end
+end

data/lib/plugems/tasks/loader.rb

@@ -0,0 +1,19 @@
+module Plugems
+	module Tasks
+		class Loader
+			def self.find_and_load
+				Plugems::Loader.gem_rake_tasks.each do |ext|
+					begin
+						load ext
+					rescue => e
+						puts "[Plugems Error]: Error (#{e}) loading rake tasks in gems #{ext}"
+						e.backtrace.each do |err|
+							puts "[Plugems Error]:   #{err}"
+					  end
+					end
+				end
+				puts "[plugems] - Loaded rake tasks from gem dependencies"
+			end
+		end
+	end
+end

data/lib/tasks/rails.rb

@@ -0,0 +1,25 @@
+# The original source of this file is here:
+# gems/rails-1.1.6/lib/tasks/rails.rb
+# See comments in ../plugems.rb
+require "#{RAILS_ROOT}/config/environment"
+
+$VERBOSE = nil
+# Need to require environment rb from rake tasks so that plugems are initialized with plugin paths
+
+if File.directory?("#{RAILS_ROOT}/vendor/rails")
+	rails_path = "#{RAILS_ROOT}/vendor/rails/railties/lib"
+else
+  rails_path = $:.grep(/gems\/rails-.*\/lib/)
+end
+
+Dir["#{rails_path}/tasks/*.rake"].each { |ext| load ext }
+
+# Load any custom rakefile extensions
+Dir["#{RAILS_ROOT}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+Dir["#{RAILS_ROOT}/vendor/plugins/*/tasks/**/*.rake"].sort.each { |ext| load ext }
+
+#Definitely load plugems own rake tasks
+Dir["#{__FILE__}/../../tasks/**/*.rake"].sort.each {|ext| load ext}
+
+# Load rake tasks from all plugems defined in application manifest
+Plugems::Tasks::Loader.find_and_load

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: plugems
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+date: 2007-05-01 00:00:00 -04:00
+summary: Dependency-management framework built on top of Ruby On Rails
+require_paths: 
+- lib
+email: rails-trunk@revolution.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: plugems
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- RHG Team
+files: 
+- init.rb
+- lib/plugems
+- lib/plugems.rb
+- lib/tasks
+- lib/plugems/loader.rb
+- lib/plugems/manifest.rb
+- lib/plugems/plugem_view_support.rb
+- lib/plugems/tasks
+- lib/plugems/tasks/loader.rb
+- lib/tasks/rails.rb
+- config/manifest.yml
+- README
+- MIT-LICENSE
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+