desert 0.1.1

data/CHANGES

@@ -0,0 +1,7 @@
+0.1.1
+- Works with edge Rails
+- Fixed double loading issue with not fully expanded load_paths.
+
+0.1.0
+- Fixed [#13346] ActionController::Base.helper raises error when helper is only in plugin
+- Desert does not require files that have been required before Desert was loaded

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Pivotal Labs
+
+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/README

@@ -0,0 +1,77 @@
+= Desert
+
+Desert is a component framework for Rails that allows you to seamlessly define in your plugins:
+* Models
+* Controllers
+* Views
+* Helpers
+* Routes
+* Migrations
+* Plugin Dependencies
+
+Classes are automatically mixed in with your own or other plugins' classes.
+This allows you to make full featured composable components.
+Desert is a replacement for Appable Plugins (http://wiki.pluginaweek.org/Appable_plugins).
+
+
+== Using desert
+
+To use Desert, you need to do only a few things:
+
+* require 'desert' before Rails::Initializer.run in environment.rb
+
+  environment.rb
+    require 'desert'
+    Rails::Initializer.run do
+    end
+
+* Install your desert plugin routes in routes.rb
+
+  map.routes_from_plugin(:spiffy)
+
+
+== Example
+Say you want to create a plugin named acts_as_spiffy.
+Desert allows Spiffy to have a set of features that can be reused and extended in several projects.
+
+The Spiffy project has a:
+* SpiffyController
+* Spiffy model
+* SpiffyHelper
+* spiffy.rhtml
+* SpiffyLib library class
+
+The Spiffy plugin acts as its own mini Rails application.
+Here is the directory structure:
+  RAILS_ROOT/vendor/plugins/spiffy/app/controllers/spiffy_controller.rb
+  RAILS_ROOT/vendor/plugins/spiffy/app/models/spiffy.rb
+  RAILS_ROOT/vendor/plugins/spiffy/app/helpers/spiffy_helper.rb
+  RAILS_ROOT/vendor/plugins/spiffy/app/views/spiffy/spiffy.rhtml
+  RAILS_ROOT/vendor/plugins/spiffy/lib/spiffy_lib.rb
+
+Now, say there is a Spiffy Store rails application that uses acts_as_spiffy.
+The Rails app can open up any of the Spiffy classes and override any of the methods.
+
+Say spiffy.rb in the Spiffy plugin is defined as:
+  class Spiffy < ActiveRecord::Base
+    def why?
+      "I just am Spiffy"
+    end
+  end
+
+The Spiffy#why method can be overridden in RAILS_ROOT/app/models/spiffy.rb
+  class Spiffy < ActiveRecord::Base
+    def why?
+      "I sell Spiffy stuff"
+    end
+  end
+
+
+== Running plugin tests
+
+You can run your plugin tests/specs like so:
+
+  rake desert:testspec:plugins PLUGIN=spiffy
+
+Leaving off the PLUGIN environment variable will cause it to run all the test/specs for
+all installed plugins, which may not be what you want.

data/Rakefile

@@ -0,0 +1,71 @@
+require "rake"
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc "Runs the Rspec suite"
+task(:default) do
+  run_suite
+end
+
+desc "Runs the Rspec suite"
+task(:spec) do
+  run_suite
+end
+
+def run_suite
+  dir = File.dirname(__FILE__)
+  system("ruby #{dir}/spec/spec_suite.rb") || raise("Example Suite failed")
+end
+
+desc "Copies the trunk to a tag with the name of the current release"
+task(:tag_release) do
+  tag_release
+end
+
+PKG_NAME = "desert"
+PKG_VERSION = "0.1.1"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  '*.rb',
+  'lib/**/*.rb',
+  'lib/generators/**/*',
+  'lib/generators/**/templates/*',
+  'examples/**/*.rb'
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Desert is a component framework for Rails that allows your plugins to be packaged as mini Rails apps."
+  s.test_files = "examples/spec_suite.rb"
+  s.description = s.summary
+
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ "README", "CHANGES" ]
+  s.rdoc_options = ["--main", "README", "--inline-source", "--line-numbers"]
+
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.require_path = 'lib'
+  s.autorequire = 'desert'
+  s.author = "Pivotal Labs"
+  s.email = "opensource@pivotallabs.com"
+  s.homepage = "http://pivotallabs.com"
+  s.rubyforge_project = "pivotalrb"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+def tag_release
+  dashed_version = PKG_VERSION.gsub('.', '-')
+  svn_user = "#{ENV["SVN_USER"]}@" || ""
+  `svn cp svn+ssh://#{svn_user}rubyforge.org/var/svn/pivotalrb/desert/trunk svn+ssh://#{svn_user}rubyforge.org/var/svn/pivotalrb/desert/tags/REL-#{dashed_version} -m 'Version #{PKG_VERSION}'`
+end

data/lib/desert.rb

@@ -0,0 +1,32 @@
+require "active_support"
+require "active_record"
+require "action_controller"
+require "action_mailer"
+
+dir = File.dirname(__FILE__)
+require "#{dir}/desert/plugin"
+require "#{dir}/desert/manager"
+require "#{dir}/desert/version_checker"
+
+if Desert::VersionChecker.rails_version_is_below_1990?
+  require "#{dir}/desert/rails/1.x/initializer"
+else
+  require "#{dir}/desert/rails/2.x/plugin"
+end
+require "#{dir}/desert/rails/dependencies"
+require "#{dir}/desert/rails/migration"
+require "#{dir}/desert/rails/migrator"
+require "#{dir}/desert/ruby/object"
+
+require "#{dir}/desert/rails/route_set"
+
+require "#{dir}/desert/plugin_migrations/migrator"
+require "#{dir}/desert/plugin_migrations/extensions/schema_statements"
+
+require "#{dir}/desert/plugin_templates/action_controller"
+if Desert::VersionChecker.rails_version_is_below_rc2?
+  require "#{dir}/desert/plugin_templates/1.x/action_mailer"
+else
+  require "#{dir}/desert/plugin_templates/2.x/action_mailer"
+end
+require "#{dir}/desert/plugin_templates/action_view"

data/lib/desert/manager.rb

@@ -0,0 +1,112 @@
+module Desert
+  class Manager # nodoc
+    class << self
+      def instance
+        @instance ||= new
+      end
+      attr_writer :instance
+
+      protected
+      def method_missing(method_name, *args, &block)
+        instance.__send__(method_name, *args, &block)
+      end
+    end
+
+    attr_reader :loading_plugin, :plugins_in_registration
+
+    def initialize
+      @plugins = []
+      @plugins_in_registration = []
+    end
+
+    def plugins
+      @plugins.dup
+    end
+
+    def load_paths
+      paths = []
+      plugin_paths.each do |component_root|
+        paths << File.join(component_root, 'app')
+        paths << File.join(component_root, 'app','models')
+        paths << File.join(component_root, 'app','controllers')
+        paths << File.join(component_root, 'app','helpers')
+        paths << File.join(component_root, 'lib')
+      end
+      Dependencies.load_paths.reverse.each do |path|
+        paths << File.expand_path(path) unless paths.include?(File.expand_path(path))
+      end
+      paths
+    end
+
+    def register_plugin(plugin_path)
+      plugin = Plugin.new(plugin_path)
+      @plugins_in_registration << plugin
+
+      yield if block_given?
+
+      Dependencies.load_paths << plugin.models_path
+      Dependencies.load_paths << plugin.controllers_path
+      Dependencies.load_paths << plugin.helpers_path
+
+      @plugins_in_registration.pop
+
+      if existing_plugin = find_plugin(plugin.name)
+        return existing_plugin
+      end
+
+      @plugins << plugin
+      plugin
+    end
+
+    def find_plugin(name_or_directory)
+      name = File.basename(File.expand_path(name_or_directory))
+      plugins.find do |plugin|
+        plugin.name == name
+      end
+    end
+
+    def plugin_exists?(name_or_directory)
+      !find_plugin(name_or_directory).nil?
+    end
+
+    def plugin_path(name)
+      plugin = find_plugin(name)
+      return nil unless plugin
+      plugin.path
+    end
+
+    def files_on_load_path(file)
+      desert_file_exists = false
+      files = []
+      load_paths.each do |path|
+        full_path = File.join(path, file)
+        full_path << '.rb' unless File.extname(full_path) == '.rb'
+        files << full_path if File.exists?(full_path)
+      end
+      files
+    end
+
+    def directory_on_load_path?(dir_suffix)
+      Desert::Manager.load_paths.each do |path|
+        return true if File.directory?(File.join(path, dir_suffix))
+      end
+      return false
+    end
+
+    def layout_paths
+      layout_paths = plugins.reverse.collect do |plugin|
+        plugin.layouts_path
+      end
+      layout_paths
+    end
+
+    protected
+    def plugin_paths
+      plugins_and_app.collect { |plugin| plugin.path }
+    end
+
+    def plugins_and_app
+      plugins + @plugins_in_registration + [Plugin.new(RAILS_ROOT)]
+    end
+  end
+end

data/lib/desert/plugin.rb

@@ -0,0 +1,80 @@
+module Desert
+  class Plugin # nodoc
+    attr_reader :name, :path
+    def initialize(path)
+      @path = File.expand_path(path)
+      @name = File.basename(@path)
+    end
+
+    def migration_path
+      "#{@path}/db/migrate"
+    end
+
+    # The path to the views for this plugin
+    def templates_path
+      "#{@path}/app/views"
+    end
+
+    def controllers_path
+      "#{@path}/app/controllers"
+    end
+
+    # TODO: Test me
+    def models_path
+      "#{@path}/app/models"
+    end
+
+    # TODO: Test me
+    def helpers_path
+      "#{@path}/app/helpers"
+    end
+
+    # The path to the layout for this plugin
+    def layouts_path
+      "#{templates_path}/layouts"
+    end
+
+    # Finds a template with the specified path
+    def find_template(template)
+      template_path = "#{templates_path}/#{template}"
+      File.exists?(template_path) ? template_path : nil
+    end
+
+    def framework_paths
+      # TODO: Don't include dirs for frameworks that are not used
+      %w(
+        railties
+        railties/lib
+        actionpack/lib
+        activesupport/lib
+        activerecord/lib
+        actionmailer/lib
+        actionwebservice/lib
+      ).map { |dir| "#{framework_root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
+    end
+
+    def ==(other)
+      self.path == other.path
+    end
+
+    def migration
+      @migration ||= PluginAWeek::PluginMigrations::Migrator.new(:up, migration_path)
+    end
+
+    def up_to_date?
+      with_current_plugin do
+        migration.latest_version <= migration.current_version
+      end
+    end
+
+    def with_current_plugin
+      old_plugin = PluginAWeek::PluginMigrations::Migrator.current_plugin
+      begin
+        PluginAWeek::PluginMigrations::Migrator.current_plugin = self
+        yield
+      ensure
+        PluginAWeek::PluginMigrations::Migrator.current_plugin = old_plugin
+      end
+    end
+  end
+end

data/lib/desert/plugin_migrations/extensions/schema_statements.rb

@@ -0,0 +1,38 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module SchemaStatements #:nodoc:
+      def initialize_schema_information_with_plugins
+        initialize_schema_information_without_plugins
+        
+        begin
+          execute "CREATE TABLE #{PluginAWeek::PluginMigrations::Migrator.schema_info_table_name} (plugin_name #{type_to_sql(:string)}, version #{type_to_sql(:integer)})"
+        rescue ActiveRecord::StatementInvalid
+          # Schema has been initialized
+        end
+      end
+      alias_method_chain :initialize_schema_information, :plugins
+      
+      def dump_schema_information_with_plugins
+        schema_information = []
+        
+        dump = dump_schema_information_without_plugins
+        schema_information << dump if dump
+        
+        begin
+          plugins = ActiveRecord::Base.connection.select_all("SELECT * FROM #{PluginAWeek::PluginMigrations::Migrator.schema_info_table_name}")
+          plugins.each do |plugin|
+            if (version = plugin['version'].to_i) > 0
+              plugin_name = ActiveRecord::Base.quote_value(plugin['plugin_name'])
+              schema_information << "INSERT INTO #{PluginAWeek::PluginMigrations::Migrator.schema_info_table_name} (plugin_name, version) VALUES (#{plugin_name}, #{version})"
+            end
+          end
+        rescue ActiveRecord::StatementInvalid 
+          # No Schema Info
+        end
+        
+        schema_information.join(";\n")
+      end
+      alias_method_chain :dump_schema_information, :plugins
+    end
+  end
+end

data/lib/desert/plugin_migrations/migrator.rb

@@ -0,0 +1,43 @@
+module PluginAWeek #:nodoc:
+  module PluginMigrations
+    # Responsible for migrating plugins.  PluginAWeek::PluginMigrations.Migrator.current_plugin
+    # indicates which plugin is currently being migrated
+    class Migrator < ActiveRecord::Migrator
+      # We need to be able to set the current plugin being migrated.
+      cattr_accessor :current_plugin
+
+      class << self
+        # Runs the migrations from a plugin, up (or down) to the version given
+        def migrate_plugin(plugin, version = nil)
+          self.current_plugin = plugin
+          migrate(plugin.migration_path, version)
+        end
+
+        def schema_info_table_name #:nodoc:
+          ActiveRecord::Base.table_name_prefix + 'plugin_schema_info' + ActiveRecord::Base.table_name_suffix
+        end
+
+        def current_version #:nodoc:
+          result = ActiveRecord::Base.connection.select_one("SELECT version FROM #{schema_info_table_name} WHERE plugin_name = '#{current_plugin.name}'")
+          if result
+            result['version'].to_i
+          else
+            # There probably isn't an entry for this plugin in the migration info table.
+            0
+          end
+        end
+      end
+
+      def set_schema_version(version)
+        version = down? ? version.to_i - 1 : version.to_i
+
+        if ActiveRecord::Base.connection.select_one("SELECT version FROM #{self.class.schema_info_table_name} WHERE plugin_name = '#{current_plugin.name}'").nil?
+          # We need to create the entry since it doesn't exist
+          ActiveRecord::Base.connection.execute("INSERT INTO #{self.class.schema_info_table_name} (version, plugin_name) VALUES (#{version},'#{current_plugin.name}')")
+        else
+          ActiveRecord::Base.connection.update("UPDATE #{self.class.schema_info_table_name} SET version = #{version} WHERE plugin_name = '#{current_plugin.name}'")
+        end
+      end
+    end
+  end
+end

data/lib/desert/plugin_templates/1.x/action_mailer.rb

@@ -0,0 +1,21 @@
+module ActionMailer #:nodoc
+  class Base #:nodoc:
+    private
+    def template_path_with_plugin_routing
+      template_paths = [template_path_without_plugin_routing]
+      Desert::Manager.plugins.reverse.each do |plugin|
+        template_paths << "#{plugin.templates_path}/#{mailer_name}"
+      end
+      "{#{template_paths * ','}}"
+    end
+    alias_method_chain :template_path, :plugin_routing
+
+    def initialize_template_class(assigns)
+      base_path = Dir["#{template_path}/#{@template}.*"].first
+      returning(template = ActionView::Base.new(File.dirname(base_path), assigns, self)) do
+        template.extend ApplicationHelper
+        template.extend self.class.master_helper_module
+      end
+    end
+  end
+end

data/lib/desert/plugin_templates/2.x/action_mailer.rb

@@ -0,0 +1,23 @@
+module ActionMailer #:nodoc
+  class Base #:nodoc:
+    private
+      def template_path_with_plugin_routing
+        template_paths = [template_path_without_plugin_routing]
+        Desert::Manager.plugins.reverse.each do |plugin|
+          template_paths << "#{plugin.templates_path}/#{mailer_name}"
+        end
+        "{#{template_paths * ','}}"
+      end
+      alias_method_chain :template_path, :plugin_routing
+
+      def initialize_template_class(assigns)
+        view_paths = Dir[template_path].collect do |path|
+          File.dirname(path)
+        end
+        returning(template = ActionView::Base.new(view_paths, assigns, self)) do
+          template.extend ApplicationHelper
+          template.extend self.class.master_helper_module
+        end
+      end
+  end
+end

data/lib/desert/plugin_templates/action_controller.rb

@@ -0,0 +1,12 @@
+module ActionController #:nodoc:
+  module Layout #:nodoc:
+    module ClassMethods #:nodoc:
+      private
+        def layout_list_with_plugin_routing
+          plugin_layouts = Desert::Manager.layout_paths.join(",")
+          layout_list_without_plugin_routing + Dir["{#{plugin_layouts}}/**/*"]
+        end
+        alias_method_chain :layout_list, :plugin_routing
+    end
+  end
+end

data/lib/desert/plugin_templates/action_view.rb

@@ -0,0 +1,36 @@
+if ActionView.const_defined?(:TemplateFinder)
+  module ActionView #:nodoc:
+    class TemplateFinder #:nodoc:
+      def initialize_with_desert_plugins(*args)
+        initialize_without_desert_plugins *args
+        
+        Desert::Manager.plugins.reverse.each do |plugin|
+          append_view_path plugin.templates_path
+        end
+      end
+      alias_method_chain :initialize, :desert_plugins
+    end
+  end
+else
+  module ActionView #:nodoc:
+    class Base #:nodoc:
+      private
+        def full_template_path_with_plugin_routing(template_path, extension)
+          full_template_path = full_template_path_without_plugin_routing(template_path, extension)
+        
+          unless File.exist?(full_template_path)
+            # Look through the plugins for the template
+            Desert::Manager.plugins.reverse.each do |plugin|
+              if plugin_template_path = plugin.find_template("#{template_path}.#{extension}")
+                full_template_path = plugin_template_path
+                break
+              end
+            end
+          end
+        
+          full_template_path
+        end
+        alias_method_chain :full_template_path, :plugin_routing
+    end
+  end
+end

data/lib/desert/rails/1.x/initializer.rb

@@ -0,0 +1,20 @@
+module Rails
+  class Initializer
+    def load_plugin_with_desert(directory)
+      return if Desert::Manager.plugin_exists?(directory)
+      plugin = Desert::Manager.register_plugin(directory) do
+        load_plugin_without_desert(directory)
+      end
+      # TODO: Can we use Initializer::Configuration#default_load_paths to do this?
+      configuration.controller_paths << plugin.controllers_path
+    end
+    alias_method_chain :load_plugin, :desert
+
+    def require_plugin(plugin_name)
+      find_plugins(configuration.plugin_paths).sort.each do |path|
+        return load_plugin(path) if File.basename(path) == plugin_name
+      end
+      raise "Plugin '#{plugin_name}' does not exist"
+    end
+  end
+end

data/lib/desert/rails/2.x/plugin.rb

@@ -0,0 +1,22 @@
+class Rails::Plugin
+  attr_accessor :initializer
+  def require_plugin(plugin_name)
+    initializer.configuration.plugin_locators.each do |locator|
+      locator.new(initializer).each do |plugin_loader|
+        return plugin_loader.load(initializer) if plugin_loader.name.to_s == plugin_name.to_s
+      end
+    end
+    raise "Plugin '#{plugin_name}' does not exist"
+  end
+
+  def load_with_desert(initializer)
+    @initializer = initializer
+    return if Desert::Manager.plugin_exists?(directory)
+    plugin = Desert::Manager.register_plugin(directory) do
+      load_without_desert(initializer)
+    end
+    # TODO: Can we use Initializer::Configuration#default_load_paths to do this?
+    initializer.configuration.controller_paths << plugin.controllers_path
+  end
+  alias_method_chain :load, :desert
+end

data/lib/desert/rails/dependencies.rb

@@ -0,0 +1,88 @@
+module Dependencies
+  def load_missing_constant_with_desert(from_mod, const_name)
+    from_mod = guard_against_anonymous_module(from_mod)
+    qualified_name = qualified_name_for from_mod, const_name
+    path_suffix = qualified_name.underscore
+
+    if define_constant_with_desert_loading(from_mod, const_name, qualified_name, path_suffix)
+      return from_mod.const_get(const_name)
+    end
+
+    if has_parent_module?(from_mod)
+      look_for_constant_in_parent_module(from_mod, const_name, qualified_name, path_suffix)
+    else
+      raise NameError, "Constant #{qualified_name} from #{path_suffix}.rb not found"
+    end
+  end
+  alias_method_chain :load_missing_constant, :desert
+
+  def load_once_path?(path)
+    load_once_paths.any? { |base| File.expand_path(path).starts_with? File.expand_path(base) }
+  end
+
+  def depend_on_with_desert(file_name, swallow_load_errors = false)
+    successfully_loaded_in_plugin = false
+    Desert::Manager.files_on_load_path(file_name).each do |file|
+      require_or_load(file)
+      successfully_loaded_in_plugin = true
+    end
+    begin
+      unless successfully_loaded_in_plugin
+        require_or_load file_name
+        loaded << File.expand_path(file_name)
+      end
+    rescue LoadError
+      if !swallow_load_errors && !successfully_loaded_in_plugin
+        raise
+      end
+    end
+  end
+  alias_method_chain :depend_on, :desert
+
+  protected
+  def define_constant_with_desert_loading(from_mod, const_name, qualified_name, path_suffix)
+    define_constant_from_file(from_mod, const_name, qualified_name, path_suffix) ||
+      define_constant_from_directory(from_mod, const_name, qualified_name, path_suffix)
+  end
+
+  def has_parent_module?(mod)
+    mod != Object
+  end
+
+  def look_for_constant_in_parent_module(from_mod, const_name, qualified_name, path_suffix)
+    return from_mod.parent.const_missing(const_name)
+  rescue NameError => e
+    raise NameError, "Constant #{qualified_name} from #{path_suffix}.rb not found\n#{e.message}"
+  end
+
+  def guard_against_anonymous_module(from_mod)
+    return Object if from_mod.name.blank?
+    return from_mod
+  end
+
+  def define_constant_from_file(from_mod, const_name, qualified_name, path_suffix)
+    files = Desert::Manager.files_on_load_path(path_suffix)
+    files.each do |file|
+      # TODO: JLM/BT -- figure out why require_or_load does not work on Windows.
+      #      require_or_load file
+      load file
+      loaded << file.gsub(/\.rb$/, '')
+      next if autoloaded_constants.include?(qualified_name)
+      next if load_once_path?(file)
+      autoloaded_constants << qualified_name
+    end
+    loaded << File.expand_path(path_suffix)
+    from_mod.const_defined?(const_name)
+  end
+
+  def define_constant_from_directory(from_mod, const_name, qualified_name, path_suffix)
+    return false unless Desert::Manager.directory_on_load_path?(path_suffix)
+
+    if autoloaded_constants.include?(qualified_name)
+      raise "Constant #{qualified_name} is already autoloaded but is not defined as a constant"
+    end
+    from_mod.const_set(const_name, Module.new)
+    autoloaded_constants << qualified_name
+    return true
+  end
+end

data/lib/desert/rails/migration.rb

@@ -0,0 +1,42 @@
+class ActiveRecord::Migration
+  module DesertMigration
+    def migrate_plugin(plugin_name, version)
+      plugin = find_plugin(plugin_name)
+      PluginAWeek::PluginMigrations::Migrator.migrate_plugin(
+        plugin,
+        version
+      )
+    end
+
+    def schema_version_equivalent_to(plugin_name, version)
+      plugin = find_plugin(plugin_name)
+      PluginAWeek::PluginMigrations::Migrator.current_plugin = plugin
+      PluginAWeek::PluginMigrations::Migrator.allocate.set_schema_version(version)
+    end
+
+    protected
+    def find_plugin(plugin_name)
+      plugin = Desert::Manager.find_plugin(plugin_name)
+      return plugin if plugin
+      raise ArgumentError, "No plugin found named #{plugin_name}"
+    end
+
+    def table_exists?(table_name)
+      vals = select_all("DESC #{table_name}")
+      return true
+    rescue ActiveRecord::StatementInvalid
+      return false
+    end
+
+    def column_exists?(table_name, column_name)
+      val = select_one("select #{column_name} from #{table_name}")
+      return true
+    rescue ActiveRecord::StatementInvalid
+      return false
+    end
+    def table_exists?(table_name)
+      ActiveRecord::Base.connection.tables.include? table_name
+    end
+  end
+  extend DesertMigration
+end

data/lib/desert/rails/migrator.rb

@@ -0,0 +1,14 @@
+class ActiveRecord::Migrator
+  module DesertMigrator
+    def latest_version
+      return 0 if migration_classes.empty?
+      migration_classes.last.first
+    end
+
+    def migration_classes_with_caching
+      @migration_classes ||= migration_classes_without_caching
+    end
+  end
+  include DesertMigrator
+  alias_method_chain :migration_classes, :caching
+end

data/lib/desert/rails/route_set.rb

@@ -0,0 +1,23 @@
+module Desert
+  module Rails
+    module RouteSet
+      # Loads the set of routes from within a plugin and evaluates them at this
+      # point within an application's main <tt>routes.rb</tt> file.
+      #
+      # Plugin routes are loaded from <tt><plugin_root>/routes.rb</tt>.
+      def routes_from_plugin(name)
+        name = name.to_s
+        routes_path = File.join(
+          Desert::Manager.plugin_path(name),
+          "config/routes.rb"
+        )
+        RAILS_DEFAULT_LOGGER.debug "Loading routes from #{routes_path}."
+        eval(IO.read(routes_path), binding, routes_path) if File.file?(routes_path)
+      end
+    end
+  end
+end
+
+class ActionController::Routing::RouteSet::Mapper
+  include Desert::Rails::RouteSet
+end

data/lib/desert/ruby/object.rb

@@ -0,0 +1,34 @@
+class Object
+  def require_with_desert(path)
+    relative_include_path = (path =~ /\.rb$/) ? path : "#{path}.rb"
+    if $".include?(relative_include_path)
+      return false
+    else
+      __each_matching_file(path) do |expanded_path|
+        require_without_desert expanded_path
+      end
+      $" << relative_include_path
+      return true
+    end
+  end
+  alias_method_chain :require, :desert
+
+  def load_with_desert(file)
+    __each_matching_file(file) do |file|
+      load_without_desert file
+    end
+  end
+  alias_method_chain :load, :desert
+
+  private
+  def __each_matching_file(file)
+    files = Desert::Manager.instance.files_on_load_path(file)
+    desert_file_exists = files.empty? ? false : true
+    files.each do |component_file|
+      yield(component_file)
+    end
+
+    return true if desert_file_exists
+    yield(file)
+  end
+end

data/lib/desert/version_checker.rb

@@ -0,0 +1,26 @@
+module Desert
+  class VersionChecker
+    class << self
+      def current_rails_version_matches?(version_requirement)
+        version_matches?(::Rails::VERSION::STRING, version_requirement)
+      end
+
+      def version_matches?(version, version_requirement)
+        Gem::Version::Requirement.new([version_requirement]).satisfied_by?(Gem::Version.new(version))
+      end
+
+      def rails_version_is_below_1990?
+        result = current_rails_version_matches?('<1.99.0')
+        result
+      end
+
+      def rails_version_is_below_rc2?
+        current_rails_version_matches?('<1.99.1')
+      end
+
+      def rails_version_is_1991?
+        current_rails_version_matches?('=1.99.1')
+      end
+    end
+  end
+end

data/lib/generators/desert_plugin/USAGE

@@ -0,0 +1,14 @@
+NAME
+     desert_plugin - creates a directory structure and starter files for a new desert plugin
+
+SYNOPSIS
+     desert_plugin [plugin name]
+
+DESCRIPTION
+     |-- vendor
+        `-- plugins
+           `-- [plugin name]
+
+EXAMPLE
+      ./script/generate desert_plugin spiffy
+

data/lib/generators/desert_plugin/desert_plugin_generator.rb

@@ -0,0 +1,40 @@
+class DesertPluginGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      m.directory "vendor/plugins/#{file_name}"
+
+      m.directory "vendor/plugins/#{file_name}/app"
+      m.directory "vendor/plugins/#{file_name}/app/controllers"
+      m.directory "vendor/plugins/#{file_name}/app/helpers"
+      m.directory "vendor/plugins/#{file_name}/app/models"
+      m.directory "vendor/plugins/#{file_name}/app/views"
+
+      m.directory "vendor/plugins/#{file_name}/config"
+      m.template "routes.rb", "vendor/plugins/#{file_name}/config/routes.rb"
+      map_route_from_plugin(m)
+
+      m.directory "vendor/plugins/#{file_name}/db"
+      m.directory "vendor/plugins/#{file_name}/db/migrate"
+      m.template "plugin_migration.rb", "vendor/plugins/#{file_name}/db/migrate/001_init_#{file_name}_plugin.rb" 
+
+      m.directory "vendor/plugins/#{file_name}/lib"
+
+      m.directory "vendor/plugins/#{file_name}/spec"
+      m.directory "vendor/plugins/#{file_name}/spec/controllers"
+      m.directory "vendor/plugins/#{file_name}/spec/fixtures"
+      m.directory "vendor/plugins/#{file_name}/spec/models"
+      m.directory "vendor/plugins/#{file_name}/spec/views"
+      m.file "spec_helper.rb", "vendor/plugins/#{file_name}/spec/spec_helper.rb" 
+
+      m.file "empty_file", "vendor/plugins/#{file_name}/init.rb"
+    end
+  end
+
+  def map_route_from_plugin(m)
+    logger.route "adding map.routes_from_plugin(:#{file_name}) to top of routes.rb"
+    sentinel = 'ActionController::Routing::Routes.draw do |map|'
+    m.gsub_file 'config/routes.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
+      "#{match}\n    map.routes_from_plugin(:#{file_name})\n"
+    end
+  end
+end

data/lib/generators/desert_plugin/templates/plugin_migration.rb

@@ -0,0 +1,11 @@
+class Init<%= class_name %>Plugin < ActiveRecord::Migration
+  def self.up
+    create_table "<%= plural_name %>", :force => true do |t|
+      t.column "some_<%= file_name %>_column", :string
+    end
+  end
+
+  def self.down
+    drop_table :<%= plural_name %>
+  end
+end

data/lib/generators/desert_plugin/templates/routes.rb

@@ -0,0 +1 @@
+resources :<%= plural_name %>

data/lib/generators/desert_plugin/templates/spec_helper.rb

@@ -0,0 +1,8 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
+require 'spec'
+require 'spec/rails'
+
+Spec::Runner.configure do |config|
+  config.fixture_path = "#{File.dirname(__FILE__)}/../spec/fixtures"
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: desert
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+date: 2008-03-18 00:00:00 -07:00
+summary: Desert is a component framework for Rails that allows your plugins to be packaged as mini Rails apps.
+require_paths: 
+- lib
+email: opensource@pivotallabs.com
+homepage: http://pivotallabs.com
+rubyforge_project: pivotalrb
+description: Desert is a component framework for Rails that allows your plugins to be packaged as mini Rails apps.
+autorequire: desert
+default_executable: 
+bindir: bin
+has_rdoc: true
+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: 
+- Pivotal Labs
+files: 
+- CHANGES
+- MIT-LICENSE
+- README
+- Rakefile
+- init.rb
+- lib/desert.rb
+- lib/generators/desert_plugin/templates/routes.rb
+- lib/generators/desert_plugin/templates/spec_helper.rb
+- lib/generators/desert_plugin/templates/plugin_migration.rb
+- lib/generators/desert_plugin/desert_plugin_generator.rb
+- lib/desert/plugin_templates/1.x/action_mailer.rb
+- lib/desert/plugin_templates/action_view.rb
+- lib/desert/plugin_templates/2.x/action_mailer.rb
+- lib/desert/plugin_templates/action_controller.rb
+- lib/desert/manager.rb
+- lib/desert/rails/1.x/initializer.rb
+- lib/desert/rails/migration.rb
+- lib/desert/rails/migrator.rb
+- lib/desert/rails/2.x/plugin.rb
+- lib/desert/rails/route_set.rb
+- lib/desert/rails/dependencies.rb
+- lib/desert/version_checker.rb
+- lib/desert/ruby/object.rb
+- lib/desert/plugin_migrations/migrator.rb
+- lib/desert/plugin_migrations/extensions/schema_statements.rb
+- lib/desert/plugin.rb
+- lib/generators/desert_plugin
+- lib/generators/desert_plugin/templates
+- lib/generators/desert_plugin/templates/empty_file
+- lib/generators/desert_plugin/USAGE
+test_files: []
+
+rdoc_options: 
+- --main
+- README
+- --inline-source
+- --line-numbers
+extra_rdoc_files: 
+- README
+- CHANGES
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+