parlement 0.3 → 0.4

data/vendor/plugins/engines/lib/{action_mailer_extensions.rb → engines/action_mailer_extensions.rb}

@@ -1,35 +1,10 @@
-#--
-# Copyright (c) 2004 David Heinemeier Hansson
-
-# 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.
-#
-# Engine Hacks by James Adam, 2005.
-#++
-
 # Overriding ActionMailer to teach it about Engines...
 module ActionMailer
   class Base
 
     # Initialize the mailer via the given +method_name+. The body will be
     # rendered and a new TMail::Mail object created.
-    def create!(method_name, *parameters) #:nodoc:
+    def old_create!(method_name, *parameters) #:nodoc:
       initialize_defaults(method_name)
       send(method_name, *parameters)
 
@@ -54,17 +29,19 @@ module ActionMailer
           # this loop expects an array of paths to actual template files which match
           # the given action name
           templates.each do |path|
-            type = (File.basename(path).split(".")[1..-2] || []).join("/")
-            #RAILS_DEFAULT_LOGGER.debug "type: #{type}"
-            next if type.empty?
-            #RAILS_DEFAULT_LOGGER.debug "other bit: #{File.basename(path).split(".")[0..-2].join('.')}"
-            @parts << Part.new(:content_type => type,
+            # TODO: don't hardcode rhtml|rxml
+            basename = File.basename(path)
+            next unless md = /^([^\.]+)\.([^\.]+\.[^\+]+)\.(rhtml|rxml)$/.match(basename)
+            
+            template_name = basename
+            content_type = md.captures[1].gsub('.', '/')
+
+            @parts << Part.new(:content_type => content_type,            
               :disposition => "inline", :charset => charset,
-              :body => render_message(File.basename(path).split(".")[0..-2].join('.'), @body))
+              :body => render_message(template_name, @body))
           end
           unless @parts.empty?
             @content_type = "multipart/alternative"
-            @charset = nil
             @parts = sort_parts(@parts, @implicit_parts_order)
           end
         end
@@ -109,7 +86,7 @@ module ActionMailer
       # Return all ActionView template paths from the app and all Engines
       def template_paths
         paths = [template_path]
-        Engines::ActiveEngines.each { |engine|
+        Engines.active.each { |engine|
           # add a path for every engine if one exists.
           engine_template_path = File.join(engine.root, "app", "views", mailer_name)
           paths << engine_template_path if File.exists?(engine_template_path)
@@ -124,7 +101,7 @@ module ActionMailer
         templates = []
         seen_names = []
         template_paths.each { |path|
-          all_templates_for_path = Dir.glob(File.join(path, "#{action}.*"))
+          all_templates_for_path = Dir.glob(File.join(path, "#{action}*"))
           all_templates_for_path.each { |template|
             name = File.basename(template)
             if !seen_names.include?(name)
@@ -152,7 +129,9 @@ module ActionMailer
       # template root
       def initialize_template_class(assigns, method_name)
         engine_template = find_template_root_for(method_name)
-        ActionView::Base.new(engine_template, assigns, self)
+        #ActionView::Base.new(engine_template, assigns, self)
+        action_view_class = Class.new(ActionView::Base).send(:include, master_helper_module)
+        action_view_class.new(engine_template, assigns, self)        
       end
 
 

data/vendor/plugins/engines/lib/{action_view_extensions.rb → engines/action_view_extensions.rb}

@@ -1,28 +1,3 @@
-#--
-# Copyright (c) 2004 David Heinemeier Hansson
-
-# 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.
-#
-# Engine Hacks by James Adam, 2005.
-#++
-
 require 'fileutils'
 
 module ::ActionView
@@ -37,7 +12,7 @@ module ::ActionView
 
         # Otherwise, check in the engines to see if the template can be found there.
         # Load this in order so that more recently started Engines will take priority.
-        Engines::ActiveEngines.each do |engine|
+        Engines.active.each do |engine|
           site_specific_path = File.join(engine.root, 'app', 'views',  template_path.to_s + '.' + extension.to_s)
           return site_specific_path if File.exist?(site_specific_path)
         end
@@ -91,20 +66,50 @@ module ::ActionView
       def engine_javascript(engine_name, *sources)
         javascript_include_tag(*convert_public_sources(engine_name, :javascript, sources))       
       end
+
+      # Returns a image tag based on the parameters passed to it
+      # Required option is option[:engine] in order to correctly idenfity the correct engine location
+      #
+      #   engine_image 'rails-engines.png', :engine => 'my_engine', :alt => 'My Engine' =>
+      #   <img src="/engine_files/my_engine/images/rails-engines.png" alt="My Engine />
+      #
+      # Any options supplied as a Hash as the last argument will be processed as in
+      # image_tag.
+      #
+      def engine_image(src, options = {})
+      	return if !src
+
+      	image_src = engine_image_src(src, options)
+
+      	options.delete(:engine)
+
+      	image_tag(image_src, options)
+      end
+
+      # Alias for engine_image
+      def engine_image_tag(src, options = {})
+        engine_image(src, options)
+      end
+
+      # Returns a path to the image stored within the engine_files
+      # Required option is option[:engine] in order to correctly idenfity the correct engine location
+      #
+      #   engine_image_src 'rails-engines.png', :engine => 'my_engine' =>
+      #   "/engine_files/my_engine/images/rails-engines.png"
+      #
+      def engine_image_src(src, options = {})
+        File.join(Engines.get(options[:engine].to_sym).public_dir, 'images', src)
+      end
       
       private
         # convert the engine public file sources into actual public paths
         # type:
         #   :stylesheet
         #   :javascript
-        # if engine_name does not end in engine, "_engine" is appended automatically. 
         def convert_public_sources(engine_name, type, sources)
           options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
           new_sources = []
         
-          full_engine_name = engine_name
-          full_engine_name += "_engine" if !(engine_name =~ /\_engine$/)
-
           case type
             when :javascript
               type_dir = "javascripts"
@@ -114,17 +119,19 @@ module ::ActionView
               ext = "css"
           end
           
-          default = "/#{Engines.config(:public_dir)}/#{full_engine_name}/#{type_dir}/#{engine_name}"
+          engine = Engines.get(engine_name)
+          
+          default = "#{engine.public_dir}/#{type_dir}/#{engine_name}"
           if defined?(RAILS_ROOT) && File.exists?(File.join(RAILS_ROOT, "public", "#{default}.#{ext}"))
             new_sources << default
           end
         
           sources.each { |name| 
-            new_sources << "/#{Engines.config(:public_dir)}/#{full_engine_name}/#{type_dir}/#{name}"
+            new_sources << "#{engine.public_dir}/#{type_dir}/#{name}"
           }
 
           new_sources << options         
         end
     end
   end
-end
+end

data/vendor/plugins/engines/lib/engines/active_record_extensions.rb

@@ -0,0 +1,19 @@
+module ::ActiveRecord
+  class Base
+    class << self
+      
+      # NOTE: Currently the Migrations system will ALWAYS wrap given table names
+      # in the prefix/suffix, so any table name set via config(:table_name), for instnace
+      # will always get wrapped in the process of migration. For this reason, whatever
+      # value you give to the config will be wrapped when set_table_name is used in the
+      # model.
+      
+      def wrapped_table_name(name)
+        table_name_prefix + name + table_name_suffix
+      end
+    end
+  end
+end
+
+# Set ActiveRecord to ignore the engine_schema_info table by default
+::ActiveRecord::SchemaDumper.ignore_tables << 'engine_schema_info'

data/vendor/plugins/engines/lib/engines/dependencies_extensions.rb

@@ -0,0 +1,118 @@
+module ::Dependencies
+  
+  # we're going to intercept the require_or_load method; lets
+  # make an alias for the current method so we can use it as the basis
+  # for loading from engines.
+  alias :rails_pre_engines_require_or_load :require_or_load
+  
+  def require_or_load(file_name)
+    if Engines.config(:edge)
+      rails_edge_require_or_load(file_name)
+    elsif Rails::VERSION::STRING =~ /^1.1/
+      # otherwise, assume we're on trunk (1.1 at the moment)
+      rails_1_1_require_or_load(file_name)
+    elsif Rails::VERSION::STRING =~ /^1.0/
+      # use the old dependency load method
+      rails_1_0_require_or_load(file_name)
+    end
+  end
+  
+  def rails_edge_require_or_load(file_name)
+    rails_1_1_require_or_load(file_name)
+  end
+  
+  def rails_1_1_require_or_load(file_name)
+    file_name = $1 if file_name =~ /^(.*)\.rb$/
+    
+    Engines.log.debug("Engines 1.1 require_or_load: #{file_name}")
+
+    # try and load the engine code first
+    # can't use model, as there's nothing in the name to indicate that the file is a 'model' file
+    # rather than a library or anything else.
+    ['controller', 'helper'].each do |type| 
+      # if we recognise this type
+      if file_name.include?('_' + type)
+ 
+        # ... go through the active engines from last started to first
+        Engines.active.each do |engine|
+ 
+          engine_file_name = File.expand_path(File.join(engine.root, 'app', "#{type}s", file_name))
+          engine_file_name = $1 if engine_file_name =~ /^(.*)\.rb$/
+          Engines.log.debug("- checking engine '#{engine.name}' for '#{engine_file_name}'")
+          if File.exist?("#{engine_file_name}.rb")
+            Engines.log.debug("==> loading from engine '#{engine.name}'")
+            rails_pre_engines_require_or_load(engine_file_name)
+          end
+        end
+      end 
+    end
+    
+    # finally, load any application-specific controller classes using the 'proper'
+    # rails load mechanism
+    rails_pre_engines_require_or_load(file_name)
+  end
+  
+  
+  def rails_1_0_require_or_load(file_name)
+    file_name = $1 if file_name =~ /^(.*)\.rb$/
+
+    Engines.log.debug "Engines 1.0.0 require_or_load '#{file_name}'"
+
+    # if the file_name ends in "_controller" or "_controller.rb", strip all
+    # path information out of it except for module context, and load it. Ditto
+    # for helpers.
+    if file_name =~ /_controller(.rb)?$/
+      require_engine_files(file_name, 'controller')
+    elsif file_name =~ /_helper(.rb)?$/ # any other files we can do this with?
+      require_engine_files(file_name, 'helper')
+    end
+    
+    # finally, load any application-specific controller classes using the 'proper'
+    # rails load mechanism
+    Engines.log.debug("--> loading from application: '#{file_name}'")
+    rails_pre_engines_require_or_load(file_name)
+    Engines.log.debug("--> Done loading.")
+  end
+  
+  # Load the given file (which should be a path to be matched from the root of each
+  # engine) from all active engines which have that file.
+  # NOTE! this method automagically strips file_name up to and including the first
+  # instance of '/app/controller'. This should correspond to the app/controller folder
+  # under RAILS_ROOT. However, if you have your Rails application residing under a
+  # path which includes /app/controller anyway, such as:
+  #
+  #   /home/username/app/controller/my_web_application # == RAILS_ROOT
+  #
+  # then you might have trouble. Sorry, just please don't have your web application
+  # running under a path like that.
+  def require_engine_files(file_name, type='')
+    Engines.log.debug "requiring #{type} file '#{file_name}'"
+    processed_file_name = file_name.gsub(/[\w\W\/\.]*app\/#{type}s\//, '')    
+    Engines.log.debug "--> rewrote to '#{processed_file_name}'"
+    Engines.active.reverse.each do |engine|
+      engine_file_name = File.join(engine.root, 'app', "#{type}s", processed_file_name)
+      engine_file_name += '.rb' unless ! load? || engine_file_name[-3..-1] == '.rb'
+      Engines.log.debug "--> checking '#{engine.name}' for #{engine_file_name}"
+      if File.exist?(engine_file_name) || 
+        (engine_file_name[-3..-1] != '.rb' && File.exist?(engine_file_name + '.rb'))
+        Engines.log.debug "--> found, loading from engine '#{engine.name}'"
+        rails_pre_engines_require_or_load(engine_file_name)
+      end
+    end     
+  end
+end
+
+
+# We only need to deal with LoadingModules in Rails 1.0.0
+if Rails::VERSION::STRING =~ /^1.0/ && !Engines.config(:edge)
+  module ::Dependencies
+    class RootLoadingModule < LoadingModule
+      # hack to allow adding to the load paths within the Rails Dependencies mechanism.
+      # this allows Engine classes to be unloaded and loaded along with standard
+      # Rails application classes.
+      def add_path(path)
+        @load_paths << (path.kind_of?(ConstantLoadPath) ? path : ConstantLoadPath.new(path))
+      end
+    end
+  end
+end

data/vendor/plugins/engines/lib/engines/migration_extensions.rb

@@ -0,0 +1,53 @@
+#require 'active_record/connection_adapters/abstract/schema_statements'
+
+module ::ActiveRecord::ConnectionAdapters::SchemaStatements
+  alias :old_initialize_schema_information :initialize_schema_information
+  def initialize_schema_information
+    # create the normal schema stuff
+    old_initialize_schema_information
+    
+    # create the engines schema stuff.    
+    begin
+      execute "CREATE TABLE #{engine_schema_info_table_name} (engine_name #{type_to_sql(:string)}, version #{type_to_sql(:integer)})"
+    rescue ActiveRecord::StatementInvalid
+      # Schema has been initialized
+    end
+  end
+
+  def engine_schema_info_table_name
+    ActiveRecord::Base.wrapped_table_name "engine_schema_info"
+  end
+end
+
+
+require 'breakpoint'
+module ::Engines
+  class EngineMigrator < ActiveRecord::Migrator
+
+    # We need to be able to set the 'current' engine being migrated.
+    cattr_accessor :current_engine
+
+    class << self
+
+      def schema_info_table_name
+        ActiveRecord::Base.wrapped_table_name "engine_schema_info"
+      end
+
+      def current_version
+        result = ActiveRecord::Base.connection.select_one("SELECT version FROM #{schema_info_table_name} WHERE engine_name = '#{current_engine.name}'")
+        if result
+          result["version"].to_i
+        else
+          # There probably isn't an entry for this engine in the migration info table.
+          # We need to create that entry, and set the version to 0
+          ActiveRecord::Base.connection.execute("INSERT INTO #{schema_info_table_name} (version, engine_name) VALUES (0,'#{current_engine.name}')")      
+          0
+        end
+      end    
+    end
+
+    def set_schema_version(version)
+      ActiveRecord::Base.connection.update("UPDATE #{self.class.schema_info_table_name} SET version = #{down? ? version.to_i - 1 : version.to_i} WHERE engine_name = '#{self.current_engine.name}'")
+    end
+  end
+end

data/vendor/plugins/engines/lib/{ruby_extensions.rb → engines/ruby_extensions.rb}

@@ -1,26 +1,3 @@
-#--
-# Copyright (c) 2005 James Adam
-#
-# 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.
-#++
-
 #--
 # Add these methods to the top-level module so that they are available in all
 # modules, etc
@@ -88,16 +65,25 @@ class ::Module
   #   MyModule.config :param_two  
   #     => 98765
   #
+  # Configuration values can also be given as a Hash:
+  #
+  #   MyModule.config :param1 => 'value1', :param2 => 'value2'
+  #
+  # Setting of these values can also be forced:
+  #
+  #   MyModule.config :param1 => 'value3', :param2 => 'value4', :force => true
+  #
+  # A value of anything other than false or nil given for the :force key will
+  # result in the new values *always* being set.
   def config(*args)
     
     raise "config expects at least one argument" if args.empty?
     
     # extract the arguments
     if args[0].is_a?(Hash)
-      # we can't override when using hash'd arguments since
-      # if > 1 hash keys are given, it's impossible to tell which
-      # one is the name of the option, and which is the override flag.
-      args[0].each { |key, value| _handle_config(key, value)}
+      override = args[0][:force]
+      args[0].delete(:force)
+      args[0].each { |key, value| _handle_config(key, value, override)}
     else
       _handle_config(*args)
     end
@@ -124,4 +110,4 @@ class ::Module
         end
       end      
     end
-end
+end