locomotive_plugins 1.0.0.beta7 → 1.0.0.beta8

data/README.md

@@ -283,10 +283,16 @@ 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 plugin object
-can also build URLs and paths for that Rack App without knowledge of where it
-is mounted. This is important because Locomotive will mount the rack
-application on a path based on the plugin's `plugin_id`. Given a string `path`
-which is a path relative to the root of the rack app,
-`plugin_object.full_path(path)` will give the full absolute path and
-`plugin_object.full_url(path)` will give the full URL.
+overriding the `rack_app` class method on the plugin class. The Rack app will
+be given some helper methods:
+
+* `plugin_object`: retrieve the plugin object.
+* `full_path(path)`: generate the full url path for `path`. The `path` variable
+  is a url path relative to the mountpoint of the Rack app.
+* `full_url(path)`: generate the full url for `path`. The `path` variable is a
+  url path relative to the mountpoint of the Rack app.
+
+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`.

data/lib/locomotive/plugin.rb

@@ -23,7 +23,6 @@ module Locomotive
     # @param base the plugin class
     def self.included(base)
       self.add_liquid_class_methods(base)
-      self.add_rack_app_helper_methods(base)
 
       base.class_eval do
         extend ActiveModel::Callbacks

data/lib/locomotive/plugin/rack_app_helpers.rb

@@ -5,86 +5,97 @@ module Locomotive
     # `rack_app` method.
     module RackAppHelpers
 
-      # @private
-      #
-      # Add class methods.
-      #
-      # @param base the class which includes this module
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
+      # Helper methods to be added to the Rack application.
+      module HelperMethods
+        attr_accessor :plugin_object
+        attr_reader :env
 
-      # @api internal
-      module ClassMethods
-        # Adds methods from RackAppHelpersClassMethods module.
+        # 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 base the plugin class to extend LiquidClassMethods
-        def add_rack_app_helper_methods(base)
-          base.extend(RackAppHelpersClassMethods)
+        # @param env the Rack environment
+        def with_env(env)
+          old_env = @env
+          @env = env
+          yield
+        ensure
+          @env = old_env
         end
-      end
 
-      # This module adds class methods for managing the mount point for the
-      # Rack App. The mount point must be set in order to properly generate
-      # paths and URLs.
-      module RackAppHelpersClassMethods
-        # Set the full URL mountpoint for the Rack app. This will be set by
-        # Locomotive CMS. The URL must be an HTTP or HTTPS url with no query
-        # parameters or hash fragments.
+        # Generate the full absolute path for the given path based on the
+        # mountpoint of this plugin's rack app.
         #
-        # @param url [String] the full URL that the Rack app is mounted on
-        def set_mountpoint(url)
-          error = lambda do |msg|
-            raise Error, "Invalid mountpoint: #{msg}"
-          end
+        # @param path [String]  the path relative to the mountpoint of the rack
+        #                       app
+        # @return the absolute path
+        def full_path(path)
+          [
+            base_uri_object.path.sub(%r{/+$}, ''),
+            path.sub(%r{^/+}, '')
+          ].join('/')
+        end
 
-          uri = URI(url)
-          unless uri.scheme =~ /^https?$/
-            error.call('only http or https allowed')
-          end
-          if uri.fragment
-            error.call('no hash fragment allowed')
-          end
-          if uri.query
-            error.call('no query string allowed')
-          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 full_url(path)
+          [
+            base_uri_object.to_s.sub(%r{/+$}, ''),
+            path.sub(%r{^/+}, '')
+          ].join('/')
+        end
 
-          @mountpoint = uri
+        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)
         end
+      end
 
-        # Get the mountpoint for this plugin class's Rack app.
+      # 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.
         #
-        # @return the mountpoint
-        def mountpoint
-          @mountpoint
+        # @param app the Rack application
+        def initialize(app)
+          @app = app
         end
-      end
 
-      # Generate the full absolute path 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 absolute path
-      def full_path(path)
-        [ mountpoint.path.sub(%r{/+$}, ''), path.sub(%r{^/+}, '') ].join('/')
+        # 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)
+          end
+        end
       end
 
-      # Generate the full URL for the given path based on the mountpoint of
-      # this plugin's rack app.
+      # 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.
       #
-      # @param path [String]  the path relative to the mountpoint of the rack
-      #                       app
-      # @return the URL
-      def full_url(path)
-        [ mountpoint.to_s.sub(%r{/+$}, ''), path.sub(%r{^/+}, '') ].join('/')
-      end
+      # @return the Rack app with helper methods
+      def prepared_rack_app
+        app = self.class.rack_app
 
-      # Get the mountpoint for this plugin's Rack app.
-      #
-      # @return the mountpoint
-      def mountpoint
-        self.class.mountpoint
+        # Extend helper module if needed
+        unless app.singleton_class.included_modules.include?(HelperMethods)
+          app.extend(HelperMethods)
+        end
+
+        app.plugin_object = self
+        RackAppWrapper.new(app)
       end
 
     end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module LocomotivePlugins
-  VERSION = '1.0.0.beta7'
+  VERSION = '1.0.0.beta8'
 end

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

@@ -5,60 +5,96 @@ module Locomotive
   module Plugin
     describe RackAppHelpers do
 
-      before(:all) do
-        PluginWithRackApp.set_mountpoint('http://www.example.com/my/path')
+      let(:config) { {} }
+
+      let(:plugin) { PluginWithRackApp.new(config) }
+
+      let(:prepared_app) { plugin.prepared_rack_app }
+
+      let(:original_app) { plugin.class.rack_app }
+
+      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)
       end
 
-      before(:each) do
-        @config = {}
-        @plugin = PluginWithRackApp.new(@config)
+      it 'should add the Rack environment to the Rack app' do
+        stub_app_call do
+          original_app.env.should == default_env
+        end
+
+        prepared_app.call(default_env)
       end
 
-      it 'should supply an absolute path based on where it is mounted' do
-        @plugin.full_path('/plugin/path').should == '/my/path/plugin/path'
-        @plugin.full_path('another//path').should == '/my/path/another//path'
+      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
+      end
+
+      it 'should not add the helper methods if they have already been added' do
+        NewRackAppClass = Class.new do
+          def method_missing(*args)
+          end
+        end
+
+        plugin = PluginWithRackApp.new(config)
+        rack_app = NewRackAppClass.new
+        plugin.class.stubs(:rack_app).returns(rack_app)
+
+        rack_app.expects(:extend).with(HelperMethods)
+        app = plugin.prepared_rack_app
+
+        plugin = PluginWithRackApp.new(config)
+        rack_app = NewRackAppClass.new
+        plugin.class.stubs(:rack_app).returns(rack_app)
+
+        app = plugin.prepared_rack_app
+        rack_app.expects(:extend).with(HelperMethods).never
+        app = plugin.prepared_rack_app
       end
 
-      it 'should supply a full URL based on where it is mounted' do
-        @plugin.full_url('/plugin/path').should ==
-          'http://www.example.com/my/path/plugin/path'
-        @plugin.full_url('another//path').should ==
-          'http://www.example.com/my/path/another//path'
+      it 'should supply an absolute path' do
+        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'
+        end
+
+        prepared_app.call(default_env)
       end
 
-      it 'should only allow URLs with proper format' do
-        old_mountpoint = PluginWithRackApp.mountpoint
-
-        bad_mountpoints = [
-          'my/path',
-          'my.server.com/my/path',
-          'ftp://my.server.com',
-          'http://my.server.com/my/path?q=value',
-          'http://my.server.com/my/path#fragment',
-          'https://my.server.com/my/path?q=value',
-          'https://my.server.com/my/path#fragment'
-        ]
-
-        good_mountpoints = [
-          'http://my.server.com/my/path',
-          'http://my.server.com:3000/my/path',
-          'https://my.server.com/my/path',
-          'https://my.server.com:3000/my/path'
-        ]
-
-        bad_mountpoints.each do |mountpoint|
-          lambda do
-            PluginWithRackApp.set_mountpoint(mountpoint)
-          end.should raise_exception(Locomotive::Plugin::Error)
-          PluginWithRackApp.mountpoint.should == old_mountpoint
+      it 'should supply a full url' do
+        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'
         end
 
-        good_mountpoints.each do |mountpoint|
-          lambda do
-            PluginWithRackApp.set_mountpoint(mountpoint)
-          end.should_not raise_exception
-          PluginWithRackApp.mountpoint.to_s.should == mountpoint
+        prepared_app.call(default_env)
+      end
+
+      protected
+
+      def default_env
+        {
+          'REQUEST_URI' => 'http://www.example.com/my/path/request/path',
+          'SCRIPT_NAME' => '/my/path'
+        }
+      end
+
+      # 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.
+      def stub_app_call(&block)
+        obj = Object.new
+        original_app.block = Proc.new do
+          obj.the_block_has_been_called
+          block.call
         end
+        obj.expects(:the_block_has_been_called).at_least_once
       end
 
     end

data/spec/support/plugins/plugin_with_rack_app.rb

@@ -3,7 +3,16 @@ class PluginWithRackApp
   include Locomotive::Plugin
 
   def self.rack_app
-    Proc.new do
+    RackApp
+  end
+
+  class RackApp
+    class << self
+      attr_accessor :block
+    end
+
+    def self.call(env)
+      block.call
       [200, {'Content-Type' => 'text/html'}, []]
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: locomotive_plugins
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta7
+  version: 1.0.0.beta8
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-24 00:00:00.000000000 Z
+date: 2013-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: locomotive_liquid