locomotive_plugins 1.0.0.beta2 → 1.0.0.beta3

data/README.md

@@ -39,6 +39,9 @@ different ID, simply supply the ID in the `register_plugin` call:
 
     LocomotivePlugins::register_plugin(BasicAuth, 'auth')
 
+See the sections below for usage examples. Also, see the
+[documentation](http://rubydoc.info/github/colibri-software/locomotive_plugins/).
+
 ### Initialization
 
 To initialize a plugin object, do not override the `initialize` method because
@@ -76,6 +79,12 @@ the Locomotive UI.
 
 ### Liquid
 
+Plugins have the ability to add liquid drops, tags, and filters to
+LocomotiveCMS. These liquid objects will only be accessible to sites which have
+enabled the plugin. All liquid objects have access to
+`@context.registers[:plugin_object]` which supplies the plugin object. This
+gives access to the config hash and other plugin methods.
+
 #### Drops
 
 A plugin can add a liquid drop which can be accessed from page templates in
@@ -199,13 +208,31 @@ Here's an example of an HTML config file:
       <p class="inline-hints">My Hint</p>
     </li>
     <li>
-      <label name="content_type_slugs">Content Types</label>
-      <select name="content_type_slugs" multiple="multiple">
+      <label name="content_type_slug">Content Types</label>
+      <select name="content_type_slug" multiple="multiple">
         {{#each content_types}}
         <option value="{{ this.slug }}"> {{ this.name }}</option>
         {{/each}}
       </select>
     </li>
+    <li>
+      <label name="do_awesome_thing">Do the awesome thing?</label>
+      <input type="checkbox" name="do_awesome_thing">
+    </li>
+
+The values of the input fields in this form will be put into the plugin
+object's config hash. Any input coming from a checkbox field will be saved as a
+boolean value, and other input fields will be saved as strings. The keys for
+the hash are taken from the `name` attribute of each input field. So, if in the
+previous example, the "My Plugin Config" field is filled with "Config Value", a
+content type with slug "my\_content\_type" is selected, and the checkbox is
+checked, the config hash will be as follows:
+
+    {
+      "my_plugin_config" => "Config Value",
+      "content_type_slug" => "my_content_type",
+      "do_awesome_thing" => true
+    }
 
 ### Database Models
 

data/lib/locomotive/plugin/liquid.rb

@@ -24,7 +24,7 @@ module Locomotive
         # normally
         def prefixed_liquid_tags(prefix)
           self.liquid_tags.inject({}) do |hash, (tag_name, tag_class)|
-            hash["#{prefix}_#{tag_name}"] = tag_subclass(tag_class)
+            hash["#{prefix}_#{tag_name}"] = tag_subclass(prefix, tag_class)
             hash
           end
         end
@@ -32,10 +32,14 @@ module Locomotive
         protected
 
         # Creates a nested subclass to handle rendering this tag
-        def tag_subclass(tag_class)
+        def tag_subclass(prefix, tag_class)
           tag_class.class_eval <<-CODE
             class TagSubclass < #{tag_class.to_s}
               include ::Locomotive::Plugin::TagSubclassMethods
+
+              def self.prefix
+                '#{prefix}'
+              end
             end
           CODE
           tag_class::TagSubclass
@@ -46,39 +50,32 @@ module Locomotive
       # Gets the module to include as a filter in liquid. It prefixes the
       # filter methods with the given string
       def prefixed_liquid_filter_module(prefix)
-        # Build up a string to eval into the module so we only need to reopen
-        # it once
-        strings_to_eval = []
+        # Create the module to be returned
+        @prefixed_liquid_filter_module = Module.new do
+          include ::Locomotive::Plugin::Liquid::PrefixedFilterModule
+        end
 
+        # Add the prefixed methods to the module
         raw_filter_modules = [self.class.liquid_filters].flatten.compact
         raw_filter_modules.each do |mod|
           mod.public_instance_methods.each do |meth|
-            strings_to_eval << <<-CODE
-              def #{prefix}_#{meth}(input)
-                self._passthrough_filter_call_for_#{prefix}('#{meth}', input)
+            @prefixed_liquid_filter_module.module_eval do
+              define_method(:"#{prefix}_#{meth}") do |input|
+                self._passthrough_filter_call(prefix, meth, input)
               end
-            CODE
+            end
           end
         end
 
-        strings_to_eval << <<-CODE
+        # Add a method which returns the modules to include for this prefix
+        @prefixed_liquid_filter_module.module_eval do
           protected
 
-          def _passthrough_object_for_#{prefix}
-            @_passthrough_object_for_#{prefix} ||= \
-              self._build_passthrough_object([#{raw_filter_modules.join(',')}])
+          define_method(:"_modules_for_#{prefix}") do
+            raw_filter_modules
           end
-
-          def _passthrough_filter_call_for_#{prefix}(meth, input)
-            self._passthrough_object_for_#{prefix}.public_send(meth, input)
-          end
-        CODE
-
-        # Eval the dynamic methods in
-        @prefixed_liquid_filter_module = Module.new do
-          include ::Locomotive::Plugin::Liquid::PrefixedFilterModule
         end
-        @prefixed_liquid_filter_module.class_eval strings_to_eval.join("\n")
+
         @prefixed_liquid_filter_module
       end
 

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

@@ -10,12 +10,51 @@ module Locomotive
 
         protected
 
+        # This method is overridden by LocomotiveCMS to provide custom
+        # functionality when a prefixed method is called
+        def filter_method_called(prefix, meth)
+        end
+
         def _build_passthrough_object(modules_to_extend)
-          Object.new.tap do |obj|
-            modules_to_extend.each do |mod|
-              obj.extend(mod)
-            end
+          obj = ::Liquid::Strainer.new(@context)
+
+          modules_to_extend.each do |mod|
+            obj.extend(mod)
+          end
+
+          obj
+        end
+
+        def _passthrough_object(prefix)
+          @_passthrough_objects ||= {}
+          obj = @_passthrough_objects[prefix]
+
+          # Return it if we have it
+          return obj if obj
+
+          # Otherwise, build it
+          modules_for_prefix_meth = :"_modules_for_#{prefix}"
+          if self.respond_to?(modules_for_prefix_meth)
+            modules = self.__send__(modules_for_prefix_meth)
+          else
+            modules = []
+          end
+
+          @_passthrough_objects[prefix] = self._build_passthrough_object(modules)
+        end
+
+        def _passthrough_filter_call(prefix, meth, input)
+          p = Proc.new do
+            self._passthrough_object(prefix).__send__(meth, input)
+          end
+
+          # Call hook and grab return value if it yields
+          ret = nil
+          self.filter_method_called(prefix, meth) do
+            ret = p.call
           end
+
+          ret || p.call
         end
 
       end

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

@@ -4,18 +4,37 @@ module Locomotive
     module Liquid
       # @private
       module TagSubclassMethods
+
         # Check to see if this tag is enabled in the liquid context and render
         # accordingly
         def render(context)
-          enabled = context.registers[:enabled_plugin_tags]
-          if enabled && enabled.include?(self.class)
-            super
-          elsif self.respond_to?(:render_disabled)
-            self.render_disabled(context)
-          else
-            ''
+          enabled_tags = context.registers[:enabled_plugin_tags]
+          enabled = enabled_tags && enabled_tags.include?(self.class)
+
+          p = Proc.new do
+            if enabled
+              super
+            elsif self.respond_to?(:render_disabled)
+              self.render_disabled(context)
+            else
+              ''
+            end
+          end
+
+          ret = nil
+          rendering_tag(self.class.prefix, enabled, context) do
+            ret = p.call
           end
+          ret || p.call
         end
+
+        protected
+
+        # This method is overridden by LocomotiveCMS to provide custom
+        # functionality when the tag is rendering
+        def rendering_tag(prefix, enabled, context)
+        end
+
       end
     end
   end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module LocomotivePlugins
-  VERSION = '1.0.0.beta2'
+  VERSION = '1.0.0.beta3'
 end

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

@@ -7,6 +7,8 @@ module Locomotive
 
       describe '#prefixed_liquid_filter_module' do
 
+        let(:strainer) { ::Liquid::Strainer.new(::Liquid::Context.new) }
+
         before(:each) do
           @plugin_with_filter = PluginWithFilter.new({})
         end
@@ -22,10 +24,9 @@ module Locomotive
         end
 
         it 'the prefixed methods should pass through to the original methods' do
-          obj = Object.new
-          obj.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix'))
-          obj.prefix_add_http('google.com').should == 'http://google.com'
-          obj.prefix_add_http('http://google.com').should == 'http://google.com'
+          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'
         end
 
         it 'includes multiple filter modules for one plugin' do
@@ -38,13 +39,54 @@ module Locomotive
         it 'works if multiple prefixed modules are mixed into the same object' do
           @plugin_with_many_filter_modules = PluginWithManyFilterModules.new({})
 
-          obj = Object.new
-          obj.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix1'))
-          obj.extend(@plugin_with_many_filter_modules.prefixed_liquid_filter_module('prefix2'))
+          strainer.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix1'))
+          strainer.extend(@plugin_with_many_filter_modules.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
+            def passthrough_objects ; @_passthrough_objects ; end
+          end
+
+          # Extend the module and create the passthrough object
+          strainer.extend(@plugin_with_filter.prefixed_liquid_filter_module('prefix'))
+          strainer.prefix_add_http('google.com').should == 'http://google.com'
 
-          obj.prefix1_add_http('google.com').should == 'http://google.com'
-          obj.prefix2_add_newline('google.com').should == "google.com\n"
-          obj.prefix2_remove_http('http://google.com').should == 'google.com'
+          # Find the context of the passthrough object
+          obj = strainer.passthrough_objects['prefix']
+          def obj.context ; @context ; end
+
+          obj.context.should == strainer.context
         end
 
       end
@@ -110,6 +152,37 @@ module Locomotive
           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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: locomotive_plugins
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta2
+  version: 1.0.0.beta3
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-23 00:00:00.000000000 Z
+date: 2012-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: locomotive_liquid