locomotive_plugins 1.0.0.beta4 → 1.0.0.beta5

data/lib/locomotive/plugin/liquid/context_helpers.rb

@@ -0,0 +1,47 @@
+
+module Locomotive
+  module Plugin
+    module Liquid
+      # @api internal
+      #
+      # Adds the plugin object to the liquid context.
+      module ContextHelpers
+
+        # Adds the plugin object to the liquid context object to be used by
+        # tags, filters, and drops. This method looks in the +:site+ register
+        # for an object which responds to +#plugin_object_for_id+ in order to
+        # populate the +:plugin_object+ register.  If such an object does not
+        # exist, the method simply yields without altering the context object.
+        # Otherwise, after yielding, the context object is reset to its
+        # previous state.
+        #
+        # @param plugin_id [String] the plugin id to use
+        # @param context [Liquid::Context] the liquid context object
+        def self.add_plugin_object_to_context(plugin_id, context)
+          site = self.fetch_site(context)
+          if site
+            old = context.registers[:plugin_object]
+            obj = site.plugin_object_for_id(plugin_id)
+            context.registers[:plugin_object] = obj
+            yield
+            context.registers[:plugin_object] = old
+          else
+            yield
+          end
+        end
+
+        protected
+
+        # Fetch the site from the context assuming it exists and responds to
+        # the +#plugin_object_for_id+ method.
+        #
+        # @param context [Liquid::Context] the liquid context object
+        # @return the site object or +nil+
+        def self.fetch_site(context)
+          site = context.registers[:site]
+          site if site.respond_to?(:plugin_object_for_id)
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/plugin/liquid/drop_extension.rb

@@ -0,0 +1,36 @@
+
+module Locomotive
+  module Plugin
+    module Liquid
+      # @api internal
+      #
+      # Extension to liquid drops added by plugins.
+      module DropExtension
+
+        # Allow setting the plugin_id, but only once.
+        def set_plugin_id(plugin_id)
+          @_plugin_id ||= plugin_id
+        end
+
+        # Add the plugin object to the context when invoked (see
+        # Liquid::Drop#invoke_drop)
+        def invoke_drop(method)
+          value = nil
+
+          ContextHelpers.add_plugin_object_to_context(_plugin_id, @context) do
+            value = super
+          end
+
+          value
+        end
+        alias :[] :invoke_drop
+
+        private
+
+        # Plugin ID (see set_plugin_id).
+        attr_reader :_plugin_id
+
+      end
+    end
+  end
+end

data/lib/locomotive/plugin/liquid/prefixed_filter_module.rb

@@ -2,19 +2,19 @@
 module Locomotive
   module Plugin
     module Liquid
-      # @private
+      # @api internal
+      #
       # This module provides functionality for the module which aggregates all
       # the prefixed filter methods. See
-      # <tt>Locomotive::Plugin::Liquid#prefixed_liquid_filter_module</tt>
+      # <tt>Locomotive::Plugin::Liquid#prefixed_liquid_filter_module</tt>.
       module PrefixedFilterModule
 
         protected
 
-        # This method is overridden by LocomotiveCMS to provide custom
-        # functionality when a prefixed method is called
-        def filter_method_called(prefix, meth)
-        end
-
+        # Build the object to use for passing through the non-prefixed methods.
+        #
+        # @param modules_to_extend [Array] the module for the passthrough object
+        # to extend
         def _build_passthrough_object(modules_to_extend)
           obj = ::Liquid::Strainer.new(@context)
 
@@ -25,6 +25,10 @@ module Locomotive
           obj
         end
 
+        # Get the passthrough object for the given prefix.
+        #
+        # @param prefix [String] the prefix to use
+        # @return the passthrough object for +prefix+
         def _passthrough_object(prefix)
           @_passthrough_objects ||= {}
           obj = @_passthrough_objects[prefix]
@@ -43,18 +47,21 @@ module Locomotive
           @_passthrough_objects[prefix] = self._build_passthrough_object(modules)
         end
 
+        # Passthrough method call with the given prefix and input.
+        #
+        # @param prefix [String] the prefix to use
+        # @param meth [Symbol] the method to call
+        # @param input [String] the input to the method
+        # @return the result of calling the method on the passthrough object
         def _passthrough_filter_call(prefix, meth, input)
-          p = Proc.new do
-            self._passthrough_object(prefix).__send__(meth, input)
-          end
+          # Setup context object and call the passthrough
+          output = nil
 
-          # Call hook and grab return value if it yields
-          ret = nil
-          self.filter_method_called(prefix, meth) do
-            ret = p.call
+          ContextHelpers.add_plugin_object_to_context(prefix, @context) do
+            output = self._passthrough_object(prefix).__send__(meth, input)
           end
 
-          ret || p.call
+          output
         end
 
       end

data/lib/locomotive/plugin/liquid/tag_subclass_methods.rb

@@ -2,17 +2,25 @@
 module Locomotive
   module Plugin
     module Liquid
-      # @private
+      # @api internal
+      #
+      # The methods shared by all tag subclasses.
       module TagSubclassMethods
 
         # Check to see if this tag is enabled in the liquid context and render
-        # accordingly
+        # accordingly.
+        #
+        # @param context [Liquid::Context] the liquid context object
+        # @return the rendered content of the superclass using +render+ or
+        #         +render_disabled+ as appropriate
         def render(context)
           enabled_tags = context.registers[:enabled_plugin_tags]
           enabled = enabled_tags && enabled_tags.include?(self.class)
 
-          p = Proc.new do
-            if enabled
+          output = nil
+
+          ContextHelpers.add_plugin_object_to_context(self.prefix, context) do
+            output = if enabled
               super
             elsif self.respond_to?(:render_disabled)
               self.render_disabled(context)
@@ -21,18 +29,12 @@ module Locomotive
             end
           end
 
-          ret = nil
-          rendering_tag(self.class.prefix, enabled, context) do
-            ret = p.call
-          end
-          ret || p.call
+          output
         end
 
-        protected
-
-        # This method is overridden by LocomotiveCMS to provide custom
-        # functionality when the tag is rendering
-        def rendering_tag(prefix, enabled, context)
+        # The prefix for this tag.
+        def prefix
+          self.class.prefix
         end
 
       end

data/lib/locomotive_plugins.rb

@@ -6,39 +6,3 @@ require 'haml'
 require 'mongoid'
 
 require 'locomotive/plugin'
-
-# The overall module for registering plugins
-module LocomotivePlugins
-
-  # Get the default ID for the given plugin class
-  #
-  # @param plugin_class[Class] the class of the plugin object
-  def self.default_id(plugin_class)
-    plugin_class.to_s.split('::').last.underscore
-  end
-
-  # Register a plugin class with a given ID. If no ID is given, the default ID
-  # is obtained by calling <tt>default_id(plugin_class)</tt>
-  #
-  # @param plugin_class[Class] the class pf the plugin to register
-  # @param plugin_id[String] the plugin ID to use
-  def self.register_plugin(plugin_class, plugin_id = nil)
-    @@registered_plugins ||= {}
-    plugin_id ||= self.default_id(plugin_class)
-    @@registered_plugins[plugin_id] = plugin_class
-  end
-
-  # Get the hash of registered plugin classes, where the keys are the IDs which
-  # were used to register the plugins
-  #
-  # @return [Hash<String, Class>] a hash of plugin IDs to plugin classes
-  def self.registered_plugins
-    @@registered_plugins ||= {}
-  end
-
-  # Remove all plugins from the registered list
-  def self.clear_registered_plugins
-    @@registered_plugins = {}
-  end
-
-end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module LocomotivePlugins
-  VERSION = '1.0.0.beta4'
+  VERSION = '1.0.0.beta5'
 end

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

@@ -0,0 +1,48 @@
+
+require 'spec_helper'
+
+module Locomotive
+  module Plugin
+    describe ClassTracker do
+
+      it 'tracks all the classes which include the module' do
+        classes = Locomotive::Plugin.plugin_classes
+        classes.should include(MyPlugin)
+        classes.should include(UselessPlugin)
+      end
+
+      it 'supports custom trackers' do
+        added_classes = []
+        num_added_classes = 0
+
+        Locomotive::Plugin.add_plugin_class_tracker do |plugin_class|
+          added_classes << plugin_class
+        end
+
+        Locomotive::Plugin.add_plugin_class_tracker do |plugin_class|
+          num_added_classes += 1
+        end
+
+        c = Class.new { include Locomotive::Plugin }
+        added_classes.should == [c]
+        num_added_classes.should == 1
+      end
+
+      it 'gives custom trackers access to the default ID' do
+        added_ids = []
+        Locomotive::Plugin.add_plugin_class_tracker do |plugin_class|
+          added_ids << plugin_class.default_plugin_id
+        end
+
+        MyNewPlugin = Class.new
+        MyNewPlugin.class_eval do
+          include Locomotive::Plugin
+        end
+
+        added_ids.count.should == 1
+        added_ids.first.should == 'my_new_plugin'
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+
+require 'spec_helper'
+
+module Locomotive
+  module Plugin
+    module Liquid
+      describe ContextHelpers do
+
+        context '#add_plugin_object_to_context' do
+
+          before(:each) do
+            @config = {}
+            @plugin = MyPlugin.new(@config)
+            @context = ::Liquid::Context.new({}, {}, {site: @site}, true)
+
+            plugin = @plugin
+            @context.registers[:site] = stub do
+              stubs(:plugin_object_for_id).with('my_plugin').returns(plugin)
+            end
+          end
+
+          it 'should add the object to the context' do
+            did_yield = false
+            ContextHelpers.add_plugin_object_to_context('my_plugin', @context) do
+              did_yield = true
+              @context.registers[:plugin_object].should == @plugin
+            end
+            did_yield.should be_true
+            @context.registers[:plugin_object].should be_nil
+          end
+
+          it 'should reset the context object' do
+            initial_object = 'initial'
+            @context.registers[:plugin_object] = initial_object
+
+            did_yield = false
+            ContextHelpers.add_plugin_object_to_context('my_plugin', @context) do
+              did_yield = true
+              @context.registers[:plugin_object].should == @plugin
+            end
+            did_yield.should be_true
+            @context.registers[:plugin_object].should == initial_object
+          end
+
+          it 'should do nothing if there is no site object in the context' do
+            @context.registers[:site] = nil
+
+            did_yield = false
+            ContextHelpers.add_plugin_object_to_context('my_plugin', @context) do
+              did_yield = true
+              @context.registers[:plugin_object].should be_nil
+            end
+            did_yield.should be_true
+            @context.registers[:plugin_object].should be_nil
+          end
+
+          it 'should do nothing if the site object has no plugin_object_for method' do
+            @context.registers[:site] = Object.new
+
+            did_yield = false
+            ContextHelpers.add_plugin_object_to_context('my_plugin', @context) do
+              did_yield = true
+              @context.registers[:plugin_object].should be_nil
+            end
+            did_yield.should be_true
+            @context.registers[:plugin_object].should be_nil
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -5,73 +5,95 @@ module Locomotive
   module Plugin
     describe Liquid do
 
+      context '#setup_liquid_context' do
+
+        before(:each) do
+          @config = {}
+          @plugin = MyPlugin.new(@config)
+          @context = ::Liquid::Context.new({}, {}, {}, true)
+          @plugin.setup_liquid_context('my_plugin', @context)
+        end
+
+        it 'should add a container for the plugin liquid drops' do
+          @context['plugins.my_plugin'].class.should == MyPlugin::MyDrop
+        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
+          @context.registers[:enabled_plugin_tags].should include(MyPlugin::MyTag::TagSubclass)
+        end
+
+        it 'should add liquid filters' do
+          @context.strainer.my_plugin_filter('input').should == 'input'
+          expect { @context.strainer.language_plugin_filter('input') }.to raise_error
+        end
+
+        it 'should add the plugin object to the context when invoking drops' do
+          ContextHelpers.expects(:add_plugin_object_to_context).with(
+            'my_plugin', @context)
+          ::Liquid::Template.parse(
+            '{{ plugins.my_plugin.dummy_method }}').render(@context)
+        end
+
+        it 'should add the plugin object to the context when calling filters' do
+          ContextHelpers.expects(:add_plugin_object_to_context).with(
+            'my_plugin', @context)
+          ::Liquid::Template.parse(
+            '{{ "test" | my_plugin_filter }}').render(@context)
+        end
+
+        it 'should add the plugin object to the context when rendering tags' do
+          MyPlugin.register_tags('my_plugin')
+          ContextHelpers.expects(:add_plugin_object_to_context).with(
+            'my_plugin', @context)
+          ::Liquid::Template.parse('{% my_plugin_my_tag %}').render(@context)
+        end
+
+      end
+
       describe '#prefixed_liquid_filter_module' do
 
         let(:strainer) { ::Liquid::Strainer.new(::Liquid::Context.new) }
 
         before(:each) do
-          @plugin_with_filter = PluginWithFilter.new({})
+          @plugin_with_filter_class = PluginWithFilter
         end
 
         it 'should contain all prefixed methods for provided filter modules' do
-          mod = @plugin_with_filter.prefixed_liquid_filter_module('prefix')
+          mod = @plugin_with_filter_class.prefixed_liquid_filter_module('prefix')
           mod.public_instance_methods.should include(:prefix_add_http)
         end
 
         it 'should not contain any of the original methods' do
-          mod = @plugin_with_filter.prefixed_liquid_filter_module('prefix')
+          mod = @plugin_with_filter_class.prefixed_liquid_filter_module('prefix')
           mod.public_instance_methods.should_not include(:add_http)
         end
 
         it 'the prefixed methods should pass through to the original methods' do
-          strainer.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix'))
+          strainer.extend(@plugin_with_filter_class.prefixed_liquid_filter_module('prefix'))
           strainer.prefix_add_http('google.com').should == 'http://google.com'
           strainer.prefix_add_http('http://google.com').should == 'http://google.com'
         end
 
         it 'includes multiple filter modules for one plugin' do
-          @plugin_with_many_filter_modules = PluginWithManyFilterModules.new({})
-          mod = @plugin_with_many_filter_modules.prefixed_liquid_filter_module('prefix')
+          @plugin_with_many_filter_modules_class = PluginWithManyFilterModules
+          mod = @plugin_with_many_filter_modules_class.prefixed_liquid_filter_module('prefix')
           mod.public_instance_methods.should include(:prefix_add_newline)
           mod.public_instance_methods.should include(:prefix_remove_http)
         end
 
         it 'works if multiple prefixed modules are mixed into the same object' do
-          @plugin_with_many_filter_modules = PluginWithManyFilterModules.new({})
+          @plugin_with_many_filter_modules_class = PluginWithManyFilterModules
 
-          strainer.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix1'))
-          strainer.extend(@plugin_with_many_filter_modules.prefixed_liquid_filter_module('prefix2'))
+          strainer.extend(@plugin_with_filter_class.prefixed_liquid_filter_module('prefix1'))
+          strainer.extend(@plugin_with_many_filter_modules_class.prefixed_liquid_filter_module('prefix2'))
 
           strainer.prefix1_add_http('google.com').should == 'http://google.com'
           strainer.prefix2_add_newline('google.com').should == "google.com\n"
           strainer.prefix2_remove_http('http://google.com').should == 'google.com'
         end
 
-        it 'should call the filter_method_called hook each time a filter is called' do
-          # Keep track of how many times filter_method_called is called
-          Locomotive::Plugin::Liquid::PrefixedFilterModule.module_eval do
-            attr_reader :count, :prefix, :method
-
-            def filter_method_called(prefix, meth)
-              @count ||= 0
-              @count += 1
-              @prefix = prefix
-              @method = meth
-              yield
-            end
-          end
-
-          # Call filter methods
-          strainer.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix'))
-          strainer.prefix_add_http('google.com').should == 'http://google.com'
-          strainer.prefix_add_http('http://google.com').should == 'http://google.com'
-
-          # Make sure filter_method_called was called as expected
-          strainer.count.should == 2
-          strainer.prefix.should == 'prefix'
-          strainer.method.should == :add_http
-        end
-
         it 'should give the current liquid context object to the passthrough objects' do
           Locomotive::Plugin::Liquid::PrefixedFilterModule.module_eval do
             attr_reader :context
@@ -79,7 +101,7 @@ module Locomotive
           end
 
           # Extend the module and create the passthrough object
-          strainer.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix'))
+          strainer.extend(@plugin_with_filter_class.prefixed_liquid_filter_module('prefix'))
           strainer.prefix_add_http('google.com').should == 'http://google.com'
 
           # Find the context of the passthrough object
@@ -97,6 +119,11 @@ module Locomotive
           @plugin_class = PluginWithTags
           @prefixed_tags = @plugin_class.prefixed_liquid_tags('prefix')
 
+          # Clear out existing registered liquid tags and register the ones we
+          # want
+          ::Liquid::Template.instance_variable_set(:@tags, nil)
+          PluginWithTags.register_tags('prefix')
+
           @enabled_tags = []
           @context = ::Liquid::Context.new
           @context.registers[:enabled_plugin_tags] = @enabled_tags
@@ -113,13 +140,20 @@ module Locomotive
           @prefixed_tags['prefix_newline'].should be < PluginWithTags::Newline
         end
 
+        it 'should register all prefixed tags in liquid' do
+          ::Liquid::Template.tags.size.should == 2
+          ::Liquid::Template.tags['prefix_paragraph'].should be \
+            < PluginWithTags::Paragraph
+          ::Liquid::Template.tags['prefix_newline'].should be \
+            < PluginWithTags::Newline
+        end
+
         it 'only renders a tag if it is enabled in the liquid context' do
           expected_output = <<-TEMPLATE
             <p>Some Text</p>
             Some Text<br />
           TEMPLATE
 
-          register_tags(@prefixed_tags)
           template = ::Liquid::Template.parse(@raw_template)
           template.render(@context).should_not == expected_output
 
@@ -134,7 +168,6 @@ module Locomotive
             Some Text
           TEMPLATE
 
-          register_tags(@prefixed_tags)
           template = ::Liquid::Template.parse(@raw_template)
           template.render(@context).should == expected_output
         end
@@ -147,48 +180,8 @@ module Locomotive
             Some Text
           TEMPLATE
 
-          register_tags(@prefixed_tags)
-          template = ::Liquid::Template.parse(@raw_template)
-          template.render(@context).should == expected_output
-        end
-
-        it 'should call the rendering_tag hook each time a tag is rendered' do
-          TagSubclassMethods.module_eval do
-            def rendering_tag(prefix, enabled, context)
-              context.registers[:rendering_tag][self.class] = {
-                prefix: prefix,
-                enabled: enabled
-              }
-              yield
-            end
-          end
-
-          expected_output = <<-TEMPLATE
-            <p>Some Text</p>
-            Some Text
-          TEMPLATE
-
-          @context.registers[:rendering_tag] = {}
-
-          register_tags(@prefixed_tags)
-          @enabled_tags << @prefixed_tags['prefix_paragraph']
           template = ::Liquid::Template.parse(@raw_template)
           template.render(@context).should == expected_output
-
-          paragraph_class = ::Locomotive::PluginWithTags::Paragraph::TagSubclass
-          newline_class = ::Locomotive::PluginWithTags::Newline::TagSubclass
-
-          hash = @context.registers[:rendering_tag]
-          hash[paragraph_class].should == { prefix: 'prefix', enabled: true }
-          hash[newline_class].should == { prefix: 'prefix', enabled: false }
-        end
-
-        protected
-
-        def register_tags(tags)
-          tags.each do |name, klass|
-            ::Liquid::Template.register_tag(name, klass)
-          end
         end
 
       end