locomotive_plugins 1.0.0.beta9 → 1.0.0.beta10

data/README.md

@@ -1,5 +1,5 @@
 
-# Locomotive Plugins [![Build Status](https://secure.travis-ci.org/colibri-software/locomotive_plugins.png)](https://secure.travis-ci.org/colibri-software/locomotive_plugins.png)
+# Locomotive Plugins [![Build Status](https://secure.travis-ci.org/colibri-software/locomotive_plugins.png)](https://travis-ci.org/colibri-software/locomotive_plugins)
 
 This gem is used to develop plugins for [Locomotive
 CMS](http://locomotivecms.com/). Plugins can be enabled or disabled on each
@@ -55,29 +55,41 @@ the
 
 ### Initialization
 
-To initialize a plugin object, do not override the `initialize` method because
-this method is defined by the `Locomotive::Plugin` module and used by
-Locomotive. Instead, override the `initialize_plugin` method.
+There are two methods which can be overridden to customize the initialization
+process. The class method `plugin_loaded` is called after the rails app first
+loads the plugin. The `initialize` method may also be overridden in order run
+custom code when the plugin object is constructed. Note that the `initialize`
+method must not take any arguments.
 
     class MyPlugin
       include Locomotive::Plugin
 
-      def initialize_plugin
-        # Custom initialization code
+      def self.plugin_loaded
+        # Initial initialization code (only called once)
+      end
+
+      def initialize
+        # Plugin object initialization code. This is called before each request
+        # for which this plugin is needed
       end
     end
 
-### Before filters
+### Callbacks
 
-A plugin may add a before filter which is run before every page load on the
-website being hosted in Locomotive CMS. The before filter has access to the
-controller which is being invoked, and a config variable which is set within
-the Locomotive UI.
+A plugin may use ActiveModel callbacks. Currently, two callbacks are supported:
+`page_render` and `rack_app_request`, both allowing `before`, `around`, and
+`after` callbacks. The `page_render` callbacks are called for all enabled
+plugins when a public-facing liquid page in LocomotiveCMS is rendered. The
+`rack_app_request` callbacks are called for a specific plugin when a request is
+about to be handed to its rack app (see the section below on including a Rack
+app in the plugin).  The `page_render` callbacks have access to the controller
+which is being invoked, and both callback types have access to the config
+variable which is set within the Locomotive UI.
 
     class BasicAuth
       include Locomotive::Plugin
 
-      before_filter :authenticate
+      before_page_render :authenticate
 
       def authenticate
         if self.config[:use_basic_auth]
@@ -107,7 +119,17 @@ Plugin code:
       include Locomotive::Plugin
 
       def to_liquid
-        { :userid => self.get_authenticated_user_id }
+        BasicAuthDrop.new(self.get_authenticated_user_id)
+      end
+    end
+
+    class BasicAuthDrop < ::Liquid::Drop
+      def initialize(userid)
+        @userid = userid
+      end
+
+      def userid
+        @userid
       end
     end
 
@@ -283,8 +305,9 @@ single site, since each site will have its own database.
 ### Rack App
 
 Plugins can supply a Rack Application to be used for request handling. Do so by
-overriding the `rack_app` class method on the plugin class. The Rack app will
-be given some helper methods:
+overriding the `rack_app` class method in the plugin class. The Rack app
+will be given some helper methods which can be called while it is handling a
+request:
 
 * `plugin_object`: retrieve the plugin object.
 * `full_path(path)`: generate the full url path for `path`. The `path` variable
@@ -296,3 +319,17 @@ The `full_path` and `full_url` helpers may be used by the Rack app to generate
 full paths and urls without explicit knowledge of the Rack app's mountpoint.
 This is important since Locomotive will mount the app to a path based on its
 `plugin_id`.
+
+The plugin object also has helpers which can be called whether or not the
+current request is being handled by a Rack app. These are helpful when a plugin
+needs to use a path or URL which would be handled by the Rack app, for example,
+to generate a link.
+
+* `rack_app_full_path(path)`: generate the full url path for `path`. Same as
+  `full_path(path)` above.
+* `rack_app_full_url(path)`: generate the full url for `path`. Same as
+  `full_url(path)` above.
+
+If your `rack_app` method creates and returns a new object instance, call the
+`mounted_rack_app` method on the plugin object or the plugin class to get the
+instance which is mounted in the rails app.

data/lib/locomotive/plugin.rb

@@ -12,6 +12,7 @@ module Locomotive
 
     include ClassTracker
     include ConfigUI
+    include LoadInitialization
     include Liquid
     include RackAppHelpers
 
@@ -22,11 +23,17 @@ module Locomotive
     #
     # @param base the plugin class
     def self.included(base)
+      self.add_load_initialization_class_methods(base)
       self.add_liquid_class_methods(base)
 
+      base.extend RackAppHelpers::ClassMethods
+
       base.class_eval do
         extend ActiveModel::Callbacks
-        define_model_callbacks :filter
+        define_model_callbacks :page_render
+        define_model_callbacks :rack_app_request
+
+        around_rack_app_request :set_plugin_object_on_rack_app
       end
 
       base.extend ClassMethods
@@ -76,9 +83,14 @@ module Locomotive
         {}
       end
 
+      # Override this method to provide functionality which will be executed
+      # when the CMS starts up and loads all plugins.
+      def plugin_loaded
+      end
+
       # Override this method to supply a rack app to be used for handling
       # requests. Locomotive CMS will mount this app on a path dependent on the
-      # `plugin_id`. See `RackAppHelpers` for some helper methods.
+      # +plugin_id+. See +RackAppHelpers+ for some helper methods.
       def rack_app
         nil
       end
@@ -93,21 +105,6 @@ module Locomotive
     # configuration hash for the plugin.
     attr_accessor :config
 
-    # Initialize by supplying the current config parameters. Note that this
-    # method should not be overridden for custom initialization of plugin
-    # objects. Instead, override the initialize_plugin method.
-    #
-    # @param config the configuration hash
-    def initialize(config)
-      self.config = config
-      self.initialize_plugin
-    end
-
-    # Override this method to supply custom initialization code for the plugin
-    # object. <b>Do not override the normal +initialize+ method</b>.
-    def initialize_plugin
-    end
-
     # Override this method to provide a liquid drop which should be available
     # in the CMS.
     def to_liquid

data/lib/locomotive/plugin/exceptions.rb

@@ -5,5 +5,8 @@ module Locomotive
     # General Locomotive::Plugin exception
     class Error < StandardError; end
 
+    # Error while plugin is being initialized
+    class InitializationError < Error; end
+
   end
 end

data/lib/locomotive/plugin/liquid.rb

@@ -129,10 +129,13 @@ module Locomotive
         end
 
         # Add drop with extension
+        context['plugins'] ||= {}
         drop = self.to_liquid
-        drop.extend(Locomotive::Plugin::Liquid::DropExtension)
-        drop.set_plugin_id(plugin_id)
-        (context['plugins'] ||= {})[plugin_id] = drop
+        if drop
+          drop.extend(Locomotive::Plugin::Liquid::DropExtension)
+          drop.set_plugin_id(plugin_id)
+          context['plugins'][plugin_id] = drop
+        end
 
         # Add filters
         context.add_filters(self.class.prefixed_liquid_filter_module(plugin_id))

data/lib/locomotive/plugin/load_initialization.rb

@@ -0,0 +1,46 @@
+
+module Locomotive
+  module Plugin
+    # This module provides initialization methods to the plugin class which Locomotive CMS will call after the plugin has been loaded into the app.
+    module LoadInitialization
+
+      # @private
+      #
+      # Add class methods.
+      #
+      # @param base the class which includes this module
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # @api internal
+      module ClassMethods
+        # Adds methods from LoadInitializationClassMethods module.
+        #
+        # @param base the plugin class to extend LoadInitializationClassMethods
+        def add_load_initialization_class_methods(base)
+          base.extend(LoadInitializationClassMethods)
+        end
+      end
+
+      # This module adds class-level initialization methods to the plugin class.
+      module LoadInitializationClassMethods
+        # Performs class-level initialization and ensures that it is only done
+        # once. If a block is given, that block is called before the custom
+        # `plugin_loaded` method is called. LocomotiveCMS calls this method on
+        # all plugins after they are loaded.
+        def do_load_initialization
+          raise InitializationError,
+            'cannot initialize plugin more than once!' if @done_load_inialization
+
+          @done_load_inialization = true
+
+          yield if block_given?
+
+          self.plugin_loaded
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/plugin/rack_app_helpers.rb

@@ -2,26 +2,12 @@
 module Locomotive
   module Plugin
     # This module adds helpers for handling the Rack app supplied by the
-    # `rack_app` method.
+    # +rack_app+ method.
     module RackAppHelpers
 
       # Helper methods to be added to the Rack application.
       module HelperMethods
         attr_accessor :plugin_object
-        attr_reader :env
-
-        # Set the env on the Rack app so that it can be retrieved later. This
-        # method will yield, and then set the env back to what it was after the
-        # block returns.
-        #
-        # @param env the Rack environment
-        def with_env(env)
-          old_env = @env
-          @env = env
-          yield
-        ensure
-          @env = old_env
-        end
 
         # Generate the full absolute path for the given path based on the
         # mountpoint of this plugin's rack app.
@@ -30,10 +16,7 @@ module Locomotive
         #                       app
         # @return the absolute path
         def full_path(path)
-          [
-            base_uri_object.path.sub(%r{/+$}, ''),
-            path.sub(%r{^/+}, '')
-          ].join('/')
+          plugin_object.rack_app_full_path(path)
         end
 
         # Generate the full URL for the given path based on the mountpoint of
@@ -43,60 +26,90 @@ module Locomotive
         #                       app
         # @return the URL
         def full_url(path)
-          [
-            base_uri_object.to_s.sub(%r{/+$}, ''),
-            path.sub(%r{^/+}, '')
-          ].join('/')
-        end
-
-        protected
-
-        def base_uri_object
-          request_uri = env['REQUEST_URI']
-          base_path = env['SCRIPT_NAME']
-          base_uri = request_uri.sub(/(#{base_path}).*$/, '\1')
-          URI(base_uri)
+          plugin_object.rack_app_full_url(path)
         end
       end
 
-      # Wrapper class around the Rack application returned by the plugin class.
-      # Acts as middleware to ensure some setup and teardown when the app is
-      # called.
-      class RackAppWrapper
-        # Initialize with the Rack application to wrap.
+      # Methods to be added to the plugin class
+      module ClassMethods
+        # Gets the Rack app and sets up additional helper methods. This value is memoized
+        # and should be used to access the rack_app, rather than calling the
+        # +rack_app+ class method directly.
         #
-        # @param app the Rack application
-        def initialize(app)
-          @app = app
-        end
-
-        # Call the underlying Rack app with the given environment.
-        #
-        # @param env the Rack environment
-        def call(env)
-          @app.with_env(env) do
-            @app.call(env)
+        # @return the Rack app with helper methods or nil if no Rack app is given
+        def mounted_rack_app
+          @mounted_rack_app ||= self.rack_app.tap do |app|
+            if app
+              app.extend(HelperMethods)
+            end
           end
         end
       end
 
-      # Adds helper methods to the Rack app and returns another Rack app which
-      # wraps it. This method gets the Rack application ready to be called by
-      # Locomotive. Locomotive CMS calls this method to get the Rack app rather
-      # than calling `rack_app` directly.
+      # The mountpoint of the Rack app.
       #
-      # @return the Rack app with helper methods
-      def prepared_rack_app
-        app = self.class.rack_app
+      # @return the mountpoint
+      def mountpoint
+        @mountpoint ||= '/'
+      end
 
-        if app
-          # Extend helper module if needed
-          unless app.singleton_class.included_modules.include?(HelperMethods)
-            app.extend(HelperMethods)
-          end
+      # Set the mountpoint of the Rack app.
+      #
+      # @param mountpoint [String] the new mountpoint
+      def mountpoint=(mountpoint)
+        @mountpoint = mountpoint
+      end
 
-          app.plugin_object = self
-          RackAppWrapper.new(app)
+      # Generate the full absolute path within the plugin's rack app for the
+      # given path based on the mountpoint.
+      #
+      # @param path [String]  the path relative to the mountpoint of the rack
+      #                       app
+      # @return the absolute path
+      def rack_app_full_path(path)
+        [
+          base_uri_object.path.sub(%r{/+$}, ''),
+          path.sub(%r{^/+}, '')
+        ].join('/')
+      end
+
+      # Generate the full URL for the given path based on the mountpoint of
+      # this plugin's rack app.
+      #
+      # @param path [String]  the path relative to the mountpoint of the rack
+      #                       app
+      # @return the URL
+      def rack_app_full_url(path)
+        [
+          base_uri_object.to_s.sub(%r{/+$}, ''),
+          path.sub(%r{^/+}, '')
+        ].join('/')
+      end
+
+      # Delegates to +ClassMethods#mounted_rack_app+.
+      #
+      # @return the rack app with the helper methods
+      def mounted_rack_app
+        self.class.mounted_rack_app
+      end
+
+      protected
+
+      def base_uri_object
+        URI(mountpoint)
+      end
+
+      def set_plugin_object_on_rack_app
+        if mounted_rack_app
+          old_plugin_object = mounted_rack_app.plugin_object
+          begin
+            mounted_rack_app.plugin_object = self
+            yield
+          ensure
+            mounted_rack_app.plugin_object = old_plugin_object
+          end
+        else
+          yield
         end
       end
 

data/lib/version.rb

@@ -1,3 +1,3 @@
 module LocomotivePlugins
-  VERSION = '1.0.0.beta9'
+  VERSION = '1.0.0.beta10'
 end

data/spec/lib/locomotive/plugin/config_ui_spec.rb

@@ -7,14 +7,22 @@ module Locomotive
 
       before(:each) do
         @config = {}
-        @plugin = MyPlugin.new(@config)
-        @plugin_with_non_string_path = PluginWithNonStringPath.new(@config)
-        @another_plugin = MyOtherPlugin.new(@config)
-        @useless_plugin = UselessPlugin.new(@config)
+
+        @plugin = MyPlugin.new
+        @plugin.config = @config
+
+        @plugin_with_non_string_path = PluginWithNonStringPath.new
+        @plugin_with_non_string_path.config = @config
+
+        @another_plugin = MyOtherPlugin.new
+        @another_plugin.config = @config
+
+        @useless_plugin = UselessPlugin.new
+        @useless_plugin.config = @config
       end
 
       it 'should return the template string of an HTML file' do
-        @plugin = MyPlugin.new({})
+        @plugin = MyPlugin.new
         filepath = @plugin.config_template_file
         @plugin.config_template_string.should == IO.read(filepath)
       end

data/spec/lib/locomotive/plugin/liquid/context_helpers_spec.rb

@@ -9,8 +9,7 @@ module Locomotive
         context '#add_plugin_object_to_context' do
 
           before(:each) do
-            @config = {}
-            @plugin = MyPlugin.new(@config)
+            @plugin = MyPlugin.new
             @context = ::Liquid::Context.new({}, {}, {site: @site}, true)
 
             plugin = @plugin

data/spec/lib/locomotive/plugin/liquid_spec.rb

@@ -8,8 +8,7 @@ module Locomotive
       context '#setup_liquid_context' do
 
         before(:each) do
-          @config = {}
-          @plugin = MyPlugin.new(@config)
+          @plugin = MyPlugin.new
           @context = ::Liquid::Context.new({}, {}, {}, true)
           @plugin.setup_liquid_context('my_plugin', @context)
         end
@@ -18,6 +17,13 @@ module Locomotive
           @context['plugins.my_plugin'].class.should == MyPlugin::MyDrop
         end
 
+        it 'should not add the drop extension to nil' do
+          plugin = UselessPlugin.new
+          plugin.setup_liquid_context('useless_plugin', @context)
+          plugin.to_liquid.should be_nil
+          plugin.to_liquid.respond_to?(:[]).should_not be_true
+        end
+
         it 'should add a set of enabled liquid tags' do
           @context.registers[:enabled_plugin_tags].class.should == Set
           @context.registers[:enabled_plugin_tags].size.should == 1

data/spec/lib/locomotive/plugin/load_initialization_spec.rb

@@ -0,0 +1,39 @@
+
+require 'spec_helper'
+
+module Locomotive
+  module Plugin
+    describe LoadInitialization do
+
+      before(:each) do
+        MyPlugin.instance_variable_set(:@done_load_inialization, false)
+      end
+
+      it 'should call plugin_loaded only once' do
+        MyPlugin.custom_attribute.should_not == 'Value'
+
+        MyPlugin.do_load_initialization
+        MyPlugin.custom_attribute.should == 'Value'
+
+        -> do
+          MyPlugin.do_load_initialization
+        end.should raise_error
+      end
+
+      it 'should call the given block' do
+        expects(:initialization_code)
+
+        MyPlugin.do_load_initialization do
+          initialization_code
+        end
+      end
+
+      it 'should not fail if no plugin_loaded method defined' do
+        lambda do
+          UselessPlugin.do_load_initialization
+        end.should_not raise_error
+      end
+
+    end
+  end
+end

data/spec/lib/locomotive/plugin/rack_app_helpers_spec.rb

@@ -5,38 +5,37 @@ module Locomotive
   module Plugin
     describe RackAppHelpers do
 
-      let(:config) { {} }
+      let(:plugin) { PluginWithRackApp.new }
 
-      let(:plugin) { PluginWithRackApp.new(config) }
+      let(:mounted_app) { plugin.class.mounted_rack_app }
 
-      let(:prepared_app) { plugin.prepared_rack_app }
-
-      let(:original_app) { plugin.class.rack_app }
+      before(:each) do
+        plugin.mountpoint = 'http://www.example.com/my/path/'
+        plugin.class.instance_variable_set(:@mounted_rack_app, nil)
+      end
 
       it 'should only supply a Rack app if one has been given' do
-        plugin = UselessPlugin.new({})
-        plugin.prepared_rack_app.should be_nil
+        plugin = UselessPlugin.new
+        plugin.class.mounted_rack_app.should be_nil
       end
 
-      it 'should add the plugin object to the Rack app' do
-        stub_app_call do
-          original_app.plugin_object.should == plugin
-        end
-
-        prepared_app.call(default_env)
+      it 'should supply a mounted app which is equal to the supplied app' do
+        mounted_app.should == plugin.class.rack_app
       end
 
-      it 'should add the Rack environment to the Rack app' do
+      it 'should add the plugin object to the Rack app' do
         stub_app_call do
-          original_app.env.should == default_env
+          mounted_app.plugin_object.should == plugin
         end
 
-        prepared_app.call(default_env)
+        mounted_app.plugin_object.should be_nil
+        mounted_app.call(default_env)
+        mounted_app.plugin_object.should be_nil
       end
 
       it 'should add path and url helpers to the Rack app' do
-        original_app.respond_to?(:full_path).should be_true
-        original_app.respond_to?(:full_url).should be_true
+        mounted_app.respond_to?(:full_path).should be_true
+        mounted_app.respond_to?(:full_url).should be_true
       end
 
       it 'should not add the helper methods if they have already been added' do
@@ -45,40 +44,60 @@ module Locomotive
           end
         end
 
-        plugin = PluginWithRackApp.new(config)
+        plugin = PluginWithRackApp.new
         rack_app = NewRackAppClass.new
         plugin.class.stubs(:rack_app).returns(rack_app)
 
         rack_app.expects(:extend).with(HelperMethods)
-        app = plugin.prepared_rack_app
+        app = plugin.class.mounted_rack_app
 
-        plugin = PluginWithRackApp.new(config)
+        plugin = PluginWithRackApp.new
         rack_app = NewRackAppClass.new
         plugin.class.stubs(:rack_app).returns(rack_app)
 
-        app = plugin.prepared_rack_app
+        app = plugin.class.mounted_rack_app
         rack_app.expects(:extend).with(HelperMethods).never
-        app = plugin.prepared_rack_app
+        app = plugin.class.mounted_rack_app
       end
 
-      it 'should supply an absolute path' do
+      it 'should supply an absolute path from the plugin object and the Rack app' do
+        path0 = '/plugin/path'
+        path1 = 'another//path'
+
+        full_path0 = '/my/path/plugin/path'
+        full_path1 = '/my/path/another//path'
+
+        plugin.rack_app_full_path(path0).should == full_path0
+        plugin.rack_app_full_path(path1).should == full_path1
+
         stub_app_call do
-          original_app.full_path('/plugin/path').should == '/my/path/plugin/path'
-          original_app.full_path('another//path').should == '/my/path/another//path'
+          mounted_app.full_path(path0).should == full_path0
+          mounted_app.full_path(path1).should == full_path1
         end
 
-        prepared_app.call(default_env)
+        mounted_app.call(default_env)
       end
 
-      it 'should supply a full url' do
+      it 'should supply a full url from the plugin object and the Rack app' do
+        path0 = '/plugin/path'
+        path1 = 'another//path'
+
+        full_url0 = 'http://www.example.com/my/path/plugin/path'
+        full_url1 = 'http://www.example.com/my/path/another//path'
+
+        plugin.rack_app_full_url(path0).should == full_url0
+        plugin.rack_app_full_url(path1).should == full_url1
+
         stub_app_call do
-          original_app.full_url('/plugin/path').should ==
-            'http://www.example.com/my/path/plugin/path'
-          original_app.full_url('another//path').should ==
-            'http://www.example.com/my/path/another//path'
+          mounted_app.full_url(path0).should == full_url0
+          mounted_app.full_url(path1).should == full_url1
         end
 
-        prepared_app.call(default_env)
+        mounted_app.call(default_env)
+      end
+
+        it 'should supply a mounted_rack_app instance method' do
+          plugin.mounted_rack_app.should == plugin.class.mounted_rack_app
       end
 
       protected
@@ -92,12 +111,14 @@ module Locomotive
 
       # Sets up an object which expects the method `the_block_has_been_called`
       # to be invoked. This way, if you stub the app call but do not call
-      # `prepared_app.call`, the spec will fail.
+      # `mounted_app.call`, the spec will fail.
       def stub_app_call(&block)
         obj = Object.new
-        original_app.block = Proc.new do
+        mounted_app.block = Proc.new do
           obj.the_block_has_been_called
-          block.call
+          plugin.run_callbacks(:rack_app_request) do
+            block.call
+          end
         end
         obj.expects(:the_block_has_been_called).at_least_once
       end

data/spec/lib/locomotive/plugin_spec.rb

@@ -5,27 +5,17 @@ module Locomotive
   describe Plugin do
 
     before(:each) do
-      @config = {}
-      @plugin = MyPlugin.new(@config)
-      @useless_plugin = UselessPlugin.new(@config)
+      @plugin = MyPlugin.new
+      @useless_plugin = UselessPlugin.new
     end
 
-    it 'should call custom initialization methods' do
-      @plugin.custom_attribute.should == 'Value'
-    end
-
-    it 'should call the given block before custom initialization methods' do
-      @plugin = MyPlugin.new(@config) do |obj|
-        obj.custom_attribute.should be_nil
-      end
-      @plugin.custom_attribute.should_not be_nil
-    end
-
-    it 'should have filter callbacks' do
-      @plugin.expects(:my_method1)
-      @plugin.expects(:my_method2)
-      @plugin.expects(:my_method3)
-      @plugin.run_callbacks(:filter) do
+    %w{page_render rack_app_request}.each do |type|
+      it "should have #{type} callbacks" do
+        @plugin.expects(:my_method1)
+        @plugin.expects(:my_method2)
+        @plugin.expects(:my_method3)
+        @plugin.run_callbacks(:"#{type}") do
+        end
       end
     end
 

data/spec/support/plugins/my_other_plugin.rb

@@ -3,7 +3,7 @@ module Locomotive
   class MyOtherPlugin
     include Locomotive::Plugin
 
-    before_filter :another_method
+    before_page_render :another_method
 
     def config_template_file
       File.join(File.dirname(__FILE__), '..', '..', 'fixtures',

data/spec/support/plugins/my_plugin.rb

@@ -15,13 +15,19 @@ module Locomotive
     class MyTag < ::Liquid::Tag
     end
 
-    before_filter :my_method1
-    after_filter :my_method2
-    around_filter :my_method3
+    before_page_render :my_method1
+    after_page_render :my_method2
+    around_page_render :my_method3
 
-    attr_accessor :custom_attribute
+    before_rack_app_request :my_method1
+    after_rack_app_request :my_method2
+    around_rack_app_request :my_method3
 
-    def initialize_plugin
+    class << self
+      attr_accessor :custom_attribute
+    end
+
+    def self.plugin_loaded
       self.custom_attribute = 'Value'
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: locomotive_plugins
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta9
+  version: 1.0.0.beta10
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-30 00:00:00.000000000 Z
+date: 2013-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: locomotive_liquid
@@ -122,6 +122,7 @@ files:
 - lib/locomotive/plugin/liquid/drop_extension.rb
 - lib/locomotive/plugin/liquid/tag_subclass_methods.rb
 - lib/locomotive/plugin/liquid/context_helpers.rb
+- lib/locomotive/plugin/load_initialization.rb
 - lib/locomotive/plugin/rack_app_helpers.rb
 - lib/locomotive/plugin/config_ui.rb
 - lib/locomotive/plugin.rb
@@ -141,6 +142,7 @@ files:
 - spec/fixtures/config_template.html
 - spec/lib/locomotive/plugin/class_tracker_spec.rb
 - spec/lib/locomotive/plugin/rack_app_helpers_spec.rb
+- spec/lib/locomotive/plugin/load_initialization_spec.rb
 - spec/lib/locomotive/plugin/liquid/context_helpers_spec.rb
 - spec/lib/locomotive/plugin/liquid_spec.rb
 - spec/lib/locomotive/plugin/config_ui_spec.rb
@@ -167,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Gem for creating plugins for Locomotive