railscart 0.0.1

data/starter-app/vendor/plugins/engines/lib/engines/assets.rb

@@ -0,0 +1,38 @@
+module Engines
+  module Assets    
+    class << self      
+      @@readme = %{Files in this directory are automatically generated from your plugins.
+They are copied from the 'assets' directories of each plugin into this directory
+each time Rails starts (script/server, script/console... and so on).
+Any edits you make will NOT persist across the next server restart; instead you
+should edit the files within the <plugin_name>/assets/ directory itself.}     
+       
+      # Ensure that the plugin asset subdirectory of RAILS_ROOT/public exists, and
+      # that we've added a little warning message to instruct developers not to mess with
+      # the files inside, since they're automatically generated.
+      def initialize_base_public_directory
+        dir = Engines.public_directory
+        unless File.exist?(dir)
+          Engines.logger.debug "Creating public engine files directory '#{dir}'"
+          FileUtils.mkdir(dir)
+        end
+        readme = File.join(dir, "README")        
+        File.open(readme, 'w') { |f| f.puts @@readme } unless File.exist?(readme)
+      end
+    
+      # Replicates the subdirectories under the plugins's +assets+ (or +public+) 
+      # directory into the corresponding public directory. See also 
+      # Plugin#public_directory for more.
+      def mirror_files_for(plugin)
+        return if plugin.public_directory.nil?
+        begin 
+          Engines.logger.debug "Attempting to copy plugin assets from '#{plugin.public_directory}' to '#{Engines.public_directory}'"
+          Engines.mirror_files_from(plugin.public_directory, File.join(Engines.public_directory, plugin.name))      
+        rescue Exception => e
+          Engines.logger.warn "WARNING: Couldn't create the public file structure for plugin '#{plugin.name}'; Error follows:"
+          Engines.logger.warn e
+        end
+      end
+    end 
+  end
+end

data/starter-app/vendor/plugins/engines/lib/engines/plugin.rb

@@ -0,0 +1,125 @@
+# An instance of Plugin is created for each plugin loaded by Rails, and
+# stored in the <tt>Engines.plugins</tt> PluginList 
+# (see Engines::RailsExtensions::RailsInitializer for more details).
+#
+#   Engines.plugins[:plugin_name]
+#
+# If this plugin contains paths in directories other than <tt>app/controllers</tt>,
+# <tt>app/helpers</tt>, <tt>app/models</tt> and <tt>components</tt>, authors can
+# declare this by adding extra paths to #code_paths:
+#
+#    Rails.plugin[:my_plugin].code_paths << "app/sweepers" << "vendor/my_lib"
+#
+# Other properties of the Plugin instance can also be set.
+module Engines
+  class Plugin < Rails::Plugin    
+    # Plugins can add code paths to this attribute in init.rb if they 
+    # need plugin directories to be added to the load path, i.e.
+    #
+    #   plugin.code_paths << 'app/other_classes'
+    #
+    # Defaults to ["app/controllers", "app/helpers", "app/models", "components"]
+    attr_accessor :code_paths
+
+    # Plugins can add paths to this attribute in init.rb if they need
+    # controllers loaded from additional locations. 
+    attr_accessor :controller_paths
+  
+    # The directory in this plugin to mirror into the shared directory
+    # under +public+.
+    #
+    # Defaults to "assets" (see default_public_directory).
+    attr_accessor :public_directory   
+    
+    protected
+  
+      # The default set of code paths which will be added to $LOAD_PATH
+      # and Dependencies.load_paths
+      def default_code_paths
+        # lib will actually be removed from the load paths when we call
+        # uniq! in #inject_into_load_paths, but it's important to keep it
+        # around (for the documentation tasks, for instance).
+        %w(app/controllers app/helpers app/models components lib)
+      end
+    
+      # The default set of code paths which will be added to the routing system
+      def default_controller_paths
+        %w(app/controllers components)
+      end
+
+      # Attempts to detect the directory to use for public files.
+      # If +assets+ exists in the plugin, this will be used. If +assets+ is missing
+      # but +public+ is found, +public+ will be used.
+      def default_public_directory
+        Engines.select_existing_paths(%w(assets public).map { |p| File.join(directory, p) }).first
+      end
+    
+    public
+  
+    def initialize(directory)
+      super directory
+      @code_paths = default_code_paths
+      @controller_paths = default_controller_paths
+      @public_directory = default_public_directory
+    end
+  
+    # Returns a list of paths this plugin wishes to make available in $LOAD_PATH
+    #
+    # Overwrites the correspondend method in the superclass  
+    def load_paths
+      report_nonexistant_or_empty_plugin! unless valid?
+      select_existing_paths :code_paths
+    end
+    
+    # Extends the superclass' load method to additionally mirror public assets
+    def load(initializer)
+      return if loaded?
+      super initializer
+      add_plugin_view_paths
+      Assets.mirror_files_for(self)
+    end    
+  
+    # for code_paths and controller_paths select those paths that actually 
+    # exist in the plugin's directory
+    def select_existing_paths(name)
+      Engines.select_existing_paths(self.send(name).map { |p| File.join(directory, p) })
+    end    
+
+    def add_plugin_view_paths
+      view_path = File.join(directory, 'app', 'views')
+      if File.exist?(view_path)
+        ActionController::Base.view_paths.insert(1, view_path) # push it just underneath the app
+      end
+    end
+
+    # The path to this plugin's public files
+    def public_asset_directory
+      "#{File.basename(Engines.public_directory)}/#{name}"
+    end
+    
+    # The path to this plugin's routes file
+    def routes_path
+      File.join(directory, "routes.rb")
+    end
+
+    # The directory containing this plugin's migrations (<tt>plugin/db/migrate</tt>)
+    def migration_directory
+      File.join(self.directory, 'db', 'migrate')
+    end
+  
+    # Returns the version number of the latest migration for this plugin. Returns
+    # nil if this plugin has no migrations.
+    def latest_migration
+      migrations = Dir[migration_directory+"/*.rb"]
+      return nil if migrations.empty?
+      migrations.map { |p| File.basename(p) }.sort.last.match(/0*(\d+)\_/)[1].to_i
+    end
+  
+    # Migrate this plugin to the given version. See Engines::Plugin::Migrator for more
+    # information.   
+    def migrate(version = nil)
+      Engines::Plugin::Migrator.migrate_plugin(self, version)
+    end
+  end
+end
+

data/starter-app/vendor/plugins/engines/lib/engines/plugin/list.rb

@@ -0,0 +1,30 @@
+# The PluginList class is an array, enhanced to allow access to loaded plugins
+# by name, and iteration over loaded plugins in order of priority. This array is used
+# by Engines::RailsExtensions::RailsInitializer to create the Engines.plugins array.
+#
+# Each loaded plugin has a corresponding Plugin instance within this array, and 
+# the order the plugins were loaded is reflected in the entries in this array.
+#
+# For more information, see the Rails module.
+module Engines
+  class Plugin
+    class List < Array
+      # Finds plugins with the set with the given name (accepts Strings or Symbols), or
+      # index. So, Engines.plugins[0] returns the first-loaded Plugin, and Engines.plugins[:engines]
+      # returns the Plugin instance for the engines plugin itself.
+      def [](name_or_index)
+        if name_or_index.is_a?(Fixnum)
+          super
+        else
+          self.find { |plugin| plugin.name.to_s == name_or_index.to_s }
+        end
+      end
+  
+      # Go through each plugin, highest priority first (last loaded first). Effectively,
+      # this is like <tt>Engines.plugins.reverse</tt>
+      def by_precedence
+        reverse
+      end
+    end
+  end
+end

data/starter-app/vendor/plugins/engines/lib/engines/plugin/loader.rb

@@ -0,0 +1,18 @@
+module Engines
+  class Plugin
+    class Loader < Rails::Plugin::Loader    
+      protected    
+        def register_plugin_as_loaded(plugin)
+          super plugin
+          Engines.plugins << plugin
+          register_to_routing(plugin)
+        end    
+        
+        # Registers the plugin's controller_paths for the routing system. 
+        def register_to_routing(plugin)
+          initializer.configuration.controller_paths += plugin.select_existing_paths(:controller_paths)
+          initializer.configuration.controller_paths.uniq!
+        end
+    end
+  end
+end

data/starter-app/vendor/plugins/engines/lib/engines/plugin/locator.rb

@@ -0,0 +1,11 @@
+module Engines
+  class Plugin
+    class FileSystemLocator < Rails::Plugin::FileSystemLocator
+      def create_plugin(path)
+        plugin = Engines::Plugin.new(path)
+        plugin.valid? ? plugin : nil
+      end        
+    end
+  end
+end
+

data/starter-app/vendor/plugins/engines/lib/engines/plugin/migrator.rb

@@ -0,0 +1,60 @@
+# The Plugin::Migrator class contains the logic to run migrations from
+# within plugin directories. The directory in which a plugin's migrations
+# should be is determined by the Plugin#migration_directory method.
+#
+# To migrate a plugin, you can simple call the migrate method (Plugin#migrate)
+# with the version number that plugin should be at. The plugin's migrations
+# will then be used to migrate up (or down) to the given version.
+#
+# For more information, see Engines::RailsExtensions::Migrations
+class Engines::Plugin::Migrator < ActiveRecord::Migrator
+
+  # We need to be able to set the 'current' engine being migrated.
+  cattr_accessor :current_plugin
+
+  # Runs the migrations from a plugin, up (or down) to the version given
+  def self.migrate_plugin(plugin, version)
+    self.current_plugin = plugin
+    migrate(plugin.migration_directory, version)
+  end
+  
+  # Returns the name of the table used to store schema information about
+  # installed plugins.
+  #
+  # See Engines.schema_info_table for more details.
+  def self.schema_info_table_name
+    ActiveRecord::Base.wrapped_table_name Engines.schema_info_table
+  end
+
+  # Returns the current version of the given plugin
+  def self.current_version(plugin=current_plugin)
+    result = ActiveRecord::Base.connection.select_one(<<-ESQL
+      SELECT version FROM #{schema_info_table_name} 
+      WHERE plugin_name = '#{plugin.name}'
+    ESQL
+    )
+    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(<<-ESQL
+        INSERT INTO #{schema_info_table_name} (version, plugin_name) 
+        VALUES (0,'#{plugin.name}')
+      ESQL
+      )      
+      0
+    end
+  end
+
+  # Sets the version of the plugin in Engines::Plugin::Migrator.current_plugin to
+  # the given version.
+  def set_schema_version(version)
+    ActiveRecord::Base.connection.update(<<-ESQL
+      UPDATE #{self.class.schema_info_table_name} 
+      SET version = #{down? ? version.to_i - 1 : version.to_i} 
+      WHERE plugin_name = '#{self.current_plugin.name}'
+    ESQL
+    )
+  end
+end

data/starter-app/vendor/plugins/engines/lib/engines/rails_extensions/action_mailer.rb

@@ -0,0 +1,85 @@
+# The way ActionMailer is coded in terms of finding templates is very restrictive, to the point
+# where all templates for rendering must exist under the single base path. This is difficult to
+# work around without re-coding significant parts of the action mailer code.
+#
+# ---
+#
+# The MailTemplates module overrides two (private) methods from ActionMailer to enable mail 
+# templates within plugins:
+#
+# [+template_path+]             which now produces the contents of #template_paths
+# [+initialize_template_class+] which now find the first matching template and creates 
+#                               an ActionVew::Base instance with the correct view_paths
+#
+# Ideally ActionMailer would use the same template-location logic as ActionView, and the same
+# view paths as ActionController::Base.view_paths, but it currently does not.
+module Engines::RailsExtensions::ActionMailer
+  def self.included(base) #:nodoc:
+    base.class_eval do
+      # TODO commented this out because it seems to break ActionMailer
+      # how can this be fixed?
+      
+      alias_method_chain :template_path, :engine_additions
+      alias_method_chain :initialize_template_class, :engine_additions
+    end
+  end
+
+  private
+  
+    #--
+    # ActionMailer::Base#create uses two mechanisms to determine the proper template file(s)
+    # to load. Firstly, it searches within the template_root for files that much the explicit
+    # (or implicit) part encodings (like signup.text.plain.erb for the signup action). 
+    # This is how implicit multipart emails are built, by the way.
+    #
+    # Secondly, it then creates an ActionMailer::Base instance with it's view_paths parameter
+    # set to the template_root, so that ActionMailer will then take over rendering the
+    # templates.
+    #
+    # Ideally, ActionMailer would pass the same set of view paths as it gets in a normal
+    # request (i.e. ActionController::Base.view_paths), so that all possible view paths
+    # were searched. However, this seems to introduce some problems with helper modules.
+    #
+    # So instead, and because we have to fool these two independent parts of ActionMailer,
+    # we fudge with the mechanisms it uses to find the templates (via template_paths, and
+    # template_path_with_engine_additions), and then intercept the creation of the ActionView
+    # instance so we can set the view_paths (in initialize_template_class_with_engine_additions).
+    #++
+  
+    # Returns all possible template paths for the current mailer, including those
+    # within the loaded plugins.
+    def template_paths
+      paths = Engines.plugins.by_precedence.map { |p| "#{p.directory}/app/views/#{mailer_name}" }
+      paths.unshift(template_path_without_engine_additions) unless Engines.disable_application_view_loading
+      paths
+    end
+
+    # Return something that Dir[] can glob against. This method is called in 
+    # ActionMailer::Base#create! and used as part of an argument to Dir. We can
+    # take advantage of this by using some of the features of Dir.glob to search
+    # multiple paths for matching files.
+    def template_path_with_engine_additions
+      "{#{template_paths.join(",")}}"
+    end
+
+    # Return an instance of ActionView::Base with the view paths set to all paths
+    # in ActionController::Base.view_paths (i.e. including all plugin view paths)
+    def initialize_template_class_with_engine_additions(assigns)
+      # I'd like to just return this, but I get problems finding methods in helper
+      # modules if the method implemention from the regular class is not called
+      # 
+      # ActionView::Base.new(ActionController::Base.view_paths.dup, assigns, self)
+      renderer = initialize_template_class_without_engine_additions(assigns)
+      renderer.view_paths = ActionController::Base.view_paths.dup
+      renderer
+    end
+end
+
+# We don't need to do this if ActionMailer hasn't been loaded.
+if Object.const_defined?(:ActionMailer) 
+  module ::ActionMailer #:nodoc:
+    class Base #:nodoc:
+      include Engines::RailsExtensions::ActionMailer
+    end
+  end
+end

data/starter-app/vendor/plugins/engines/lib/engines/rails_extensions/active_record.rb

@@ -0,0 +1,24 @@
+# Here we add a single helpful method to ActiveRecord::Base. This method may be deprecated
+# in the future, since support for the Module#config mechanism which required it has
+# also been dropped.
+module Engines::RailsExtensions::ActiveRecord
+  # NOTE: Currently the Migrations system will ALWAYS wrap given table names
+  # in the prefix/suffix, so any table name set via ActiveRecord::Base#set_table_name, 
+  # for instance 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.
+  #
+  # This method is useful for determining the actual name (including prefix and 
+  # suffix) that Rails will use for a model, given a particular set_table_name
+  # parameter.
+  def wrapped_table_name(name)
+    table_name_prefix + name + table_name_suffix
+  end
+  
+end
+
+module ::ActiveRecord #:nodoc:
+  class Base #:nodoc:
+    extend Engines::RailsExtensions::ActiveRecord
+  end
+end

data/starter-app/vendor/plugins/engines/lib/engines/rails_extensions/asset_helpers.rb

@@ -0,0 +1,119 @@
+# The engines plugin makes it trivial to share public assets using plugins. 
+# To do this, include an <tt>assets</tt> directory within your plugin, and put
+# your javascripts, stylesheets and images in subdirectories of that folder:
+#
+#   my_plugin
+#     |- init.rb
+#     |- lib/
+#     |- assets/
+#          |- javascripts/
+#          |    |- my_functions.js
+#          |
+#          |- stylesheets/
+#          |    |- my_styles.css
+#          |
+#          |- images/
+#               |- my_face.jpg
+#
+# Files within the <tt>asset</tt> structure are automatically mirrored into
+# a publicly-accessible folder each time your application starts (see
+# Engines::Assets#mirror_assets).
+#
+#
+# == Using plugin assets in views
+#
+# It's also simple to use Rails' helpers in your views to use plugin assets.
+# The default helper methods have been enhanced by the engines plugin to accept
+# a <tt>:plugin</tt> option, indicating the plugin containing the desired asset.
+#
+# For example, it's easy to use plugin assets in your layouts:
+#
+#   <%= stylesheet_link_tag "my_styles", :plugin => "my_plugin", :media => "screen" %>
+#   <%= javascript_include_tag "my_functions", :plugin => "my_plugin" %>
+# 
+# ... and similarly in views and partials, it's easy to use plugin images:
+#
+#   <%= image_tag "my_face", :plugin => "my_plugin" %>
+#   <!-- or -->
+#   <%= image_path "my_face", :plugin => "my_plugin" %>
+#
+# Where the default helpers allow the specification of more than one file (i.e. the
+# javascript and stylesheet helpers), you can do similarly for multiple assets from 
+# within a single plugin.
+#
+# ---
+#
+# This module enhances four of the methods from ActionView::Helpers::AssetTagHelper:
+#
+#  * stylesheet_link_tag
+#  * javascript_include_tag
+#  * image_path
+#  * image_tag
+#
+# Each one of these methods now accepts the key/value pair <tt>:plugin => "plugin_name"</tt>,
+# which can be used to specify the originating plugin for any assets.
+#
+module Engines::RailsExtensions::AssetHelpers
+  def self.included(base) #:nodoc:
+    base.class_eval do
+      [:stylesheet_link_tag, :javascript_include_tag, :image_path, :image_tag].each do |m|
+        alias_method_chain m, :engine_additions
+      end
+    end
+  end
+
+  # Adds plugin functionality to Rails' default stylesheet_link_tag method.
+  def stylesheet_link_tag_with_engine_additions(*sources)
+    stylesheet_link_tag_without_engine_additions(*Engines::RailsExtensions::AssetHelpers.pluginify_sources("stylesheets", *sources))
+  end
+
+  # Adds plugin functionality to Rails' default javascript_include_tag method.  
+  def javascript_include_tag_with_engine_additions(*sources)
+    javascript_include_tag_without_engine_additions(*Engines::RailsExtensions::AssetHelpers.pluginify_sources("javascripts", *sources))
+  end
+
+  #--
+  # Our modified image_path now takes a 'plugin' option, though it doesn't require it
+  #++
+
+  # Adds plugin functionality to Rails' default image_path method.
+  def image_path_with_engine_additions(source, options={})
+    options.stringify_keys!
+    source = Engines::RailsExtensions::AssetHelpers.plugin_asset_path(options["plugin"], "images", source) if options["plugin"]
+    image_path_without_engine_additions(source)
+  end
+
+  # Adds plugin functionality to Rails' default image_tag method.
+  def image_tag_with_engine_additions(source, options={})
+    options.stringify_keys!
+    if options["plugin"]
+      source = Engines::RailsExtensions::AssetHelpers.plugin_asset_path(options["plugin"], "images", source)
+      options.delete("plugin")
+    end
+    image_tag_without_engine_additions(source, options)
+  end
+
+  #--
+  # The following are methods on this module directly because of the weird-freaky way
+  # Rails creates the helper instance that views actually get
+  #++
+
+  # Convert sources to the paths for the given plugin, if any plugin option is given
+  def self.pluginify_sources(type, *sources)
+    options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
+    sources.map! { |s| plugin_asset_path(options["plugin"], type, s) } if options["plugin"]
+    options.delete("plugin") # we don't want it appearing in the HTML
+    sources << options # re-add options      
+  end  
+
+  # Returns the publicly-addressable relative URI for the given asset, type and plugin
+  def self.plugin_asset_path(plugin_name, type, asset)
+    raise "No plugin called '#{plugin_name}' - please use the full name of a loaded plugin." if Engines.plugins[plugin_name].nil?
+    "/#{Engines.plugins[plugin_name].public_asset_directory}/#{type}/#{asset}"
+  end
+  
+end
+
+module ::ActionView::Helpers::AssetTagHelper #:nodoc:
+  include Engines::RailsExtensions::AssetHelpers
+end