locomotive_plugins 1.0.0.beta2

data/lib/locomotive/plugin/db_model.rb

@@ -0,0 +1,10 @@
+
+module Locomotive
+  module Plugin
+    # All classes to be persisted by a plugin should inherit from this class
+    # (see Locomotive::Plugin::ClassMethods #has_many or #has_one)
+    class DBModel
+      include ::Mongoid::Document
+    end
+  end
+end

data/lib/locomotive/plugin/db_model_container.rb

@@ -0,0 +1,10 @@
+
+module Locomotive
+  module Plugin
+    # The superclass of the DBModelContainer object for each plugin. This
+    # container has the actual relationships to the database objects
+    class DBModelContainer
+      include Mongoid::Document
+    end
+  end
+end

data/lib/locomotive/plugin/db_models.rb

@@ -0,0 +1,86 @@
+
+module Locomotive
+  module Plugin
+
+    # Utility methods for dealing with DB Models
+    module DBModels
+
+      # @private
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # @private
+      module ClassMethods
+
+        def add_db_model_class_methods(base)
+          base.class_eval <<-CODE
+            class DBModelContainer < ::Locomotive::Plugin::DBModelContainer
+            end
+
+            def self.db_model_container_class
+              DBModelContainer
+            end
+          CODE
+          base.extend DBModelClassMethods
+        end
+
+      end
+
+      # @private
+      module DBModelClassMethods
+
+        protected
+
+        def create_has_many_relationship(name, klass)
+          self.db_model_container_class.embeds_many(name,
+            class_name: klass.to_s, inverse_of: :db_model_container)
+          klass.embedded_in(:db_model_container,
+            class_name: db_model_container_class.to_s, inverse_of: name)
+
+          self.define_passthrough_methods_to_container(name, "#{name}=")
+        end
+
+        def create_has_one_relationship(name, klass)
+          self.db_model_container_class.embeds_one(name,
+            class_name: klass.to_s, inverse_of: :db_model_container)
+          klass.embedded_in(:db_model_container,
+            class_name: db_model_container_class.to_s, inverse_of: name)
+
+          self.define_passthrough_methods_to_container(name, "#{name}=",
+            "build_#{name}", "create_#{name}")
+        end
+
+        def define_passthrough_methods_to_container(*methods)
+          class_eval <<-EOF
+            %w{#{methods.join(' ')}}.each do |meth|
+              define_method(meth) do |*args|
+                @db_model_container.send(meth, *args)
+              end
+            end
+          EOF
+        end
+
+      end
+
+      # Save the DB Model container
+      def save_db_model_container
+        self.db_model_container.save
+      end
+
+      # Get the DB Model container
+      def db_model_container
+        @db_model_container || load_or_create_db_model_container!
+      end
+
+      protected
+
+      def load_or_create_db_model_container!
+        @db_model_container = self.class.db_model_container_class.first \
+          || self.class.db_model_container_class.new
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/plugin/liquid.rb

@@ -0,0 +1,87 @@
+
+module Locomotive
+  module Plugin
+    module Liquid
+
+      # @private
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # @private
+      module ClassMethods
+        def add_liquid_tag_methods(base)
+          base.extend(LiquidTagMethods)
+        end
+      end
+
+      module LiquidTagMethods
+
+        # Returns a hash of tag names and tag classes to be registered in the
+        # liquid environment. The tag names are prefixed by the given prefix,
+        # and the tag classes are modified so that they check the liquid
+        # context to determine whether they are enabled and should render
+        # 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
+          end
+        end
+
+        protected
+
+        # Creates a nested subclass to handle rendering this tag
+        def tag_subclass(tag_class)
+          tag_class.class_eval <<-CODE
+            class TagSubclass < #{tag_class.to_s}
+              include ::Locomotive::Plugin::TagSubclassMethods
+            end
+          CODE
+          tag_class::TagSubclass
+        end
+
+      end
+
+      # 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 = []
+
+        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)
+              end
+            CODE
+          end
+        end
+
+        strings_to_eval << <<-CODE
+          protected
+
+          def _passthrough_object_for_#{prefix}
+            @_passthrough_object_for_#{prefix} ||= \
+              self._build_passthrough_object([#{raw_filter_modules.join(',')}])
+          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
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+
+module Locomotive
+  module Plugin
+    module Liquid
+      # @private
+      # This module provides functionality for the module which aggregates all
+      # the prefixed filter methods. See
+      # <tt>Locomotive::Plugin::Liquid#prefixed_liquid_filter_module</tt>
+      module PrefixedFilterModule
+
+        protected
+
+        def _build_passthrough_object(modules_to_extend)
+          Object.new.tap do |obj|
+            modules_to_extend.each do |mod|
+              obj.extend(mod)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+
+module Locomotive
+  module Plugin
+    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
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/locomotive_plugins.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'liquid'
+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

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

data/spec/fixtures/config_template.haml

@@ -0,0 +1,2 @@
+%li
+  %p This is my template!

data/spec/fixtures/config_template.html

@@ -0,0 +1,3 @@
+<li>
+    <p>This is my template!</p>
+</li>

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

@@ -0,0 +1,41 @@
+
+require 'spec_helper'
+
+module Locomotive
+  module Plugin
+    describe ConfigUI do
+
+      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)
+      end
+
+      it 'should return the template string of an HTML file' do
+        @plugin = MyPlugin.new({})
+        filepath = @plugin.config_template_file
+        @plugin.config_template_string.should == IO.read(filepath)
+      end
+
+      it 'should handle non-string paths' do
+        filepath = @plugin_with_non_string_path.config_template_file
+        template = @plugin_with_non_string_path.config_template_string
+        template.should == IO.read(filepath.to_s)
+      end
+
+      it 'should return nil for the template string if no file is specified' do
+        @useless_plugin.config_template_string.should be_nil
+      end
+
+      it 'should compile the template string for a HAML file' do
+        filepath = @another_plugin.config_template_file
+        haml = IO.read(filepath)
+        html = Haml::Engine.new(haml).render
+        @another_plugin.config_template_string.should == html
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+
+module Locomotive
+  module Plugin
+    describe DBModels do
+
+      before(:each) do
+        plugin = PluginWithDBModel.new({})
+        plugin.build_visit_count(count: 5)
+        plugin.items.build(name: 'First Item')
+        plugin.items.build(name: 'Second Item')
+        plugin.save_db_model_container.should be_true
+
+        # Reload from the database
+        @plugin_with_db_model = PluginWithDBModel.new({})
+      end
+
+      it 'should persist DBModel items' do
+        @plugin_with_db_model.visit_count.count.should == 5
+
+        @plugin_with_db_model.items.count.should == 2
+        @plugin_with_db_model.items[0].name.should == 'First Item'
+        @plugin_with_db_model.items[1].name.should == 'Second Item'
+      end
+
+      it 'should allow mongoid queries on persisted DBModel items' do
+        @plugin_with_db_model.items.where(name: /First/).count.should == 1
+        @plugin_with_db_model.items.where(name: /First/).first.name.should == 'First Item'
+
+        @plugin_with_db_model.items.where(name: /Item/).count.should == 2
+        @plugin_with_db_model.items.where(name: /Item/)[0].name.should == 'First Item'
+        @plugin_with_db_model.items.where(name: /Item/)[1].name.should == 'Second Item'
+      end
+
+      it 'should embed DBModel items in a document for the plugin class' do
+        @plugin_with_db_model.visit_count.db_model_container.kind_of?(
+          PluginWithDBModel::DBModelContainer).should be_true
+        @plugin_with_db_model.items.first.db_model_container.kind_of?(
+          PluginWithDBModel::DBModelContainer).should be_true
+
+        @plugin_with_db_model.visit_count.relations[
+          'db_model_container'].relation.should \
+          == Mongoid::Relations::Embedded::In
+      end
+
+      it 'should run all validations for DBModel items' do
+        @plugin_with_db_model.items.build(name: '')
+        @plugin_with_db_model.save_db_model_container.should be_false
+
+        @plugin_with_db_model.db_model_container.errors.messages.should == {
+          :items => [ 'is invalid' ]
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+
+require 'spec_helper'
+
+module Locomotive
+  module Plugin
+    describe Liquid do
+
+      describe '#prefixed_liquid_filter_module' do
+
+        before(:each) do
+          @plugin_with_filter = PluginWithFilter.new({})
+        end
+
+        it 'should contain all prefixed methods for provided filter modules' do
+          mod = @plugin_with_filter.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.public_instance_methods.should_not include(:add_http)
+        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'
+        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')
+          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({})
+
+          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'))
+
+          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'
+        end
+
+      end
+
+      describe 'liquid tags' do
+
+        before(:each) do
+          @plugin_class = PluginWithTags
+          @prefixed_tags = @plugin_class.prefixed_liquid_tags('prefix')
+
+          @enabled_tags = []
+          @context = ::Liquid::Context.new
+          @context.registers[:enabled_plugin_tags] = @enabled_tags
+
+          @raw_template = <<-TEMPLATE
+            {% prefix_paragraph %}Some Text{% endprefix_paragraph %}
+            Some Text{% prefix_newline %}
+          TEMPLATE
+        end
+
+        it 'supplies the prefixed tag names along with subclasses of the tag classes' do
+          @prefixed_tags.size.should == 2
+          @prefixed_tags['prefix_paragraph'].should be < PluginWithTags::Paragraph
+          @prefixed_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
+
+          @enabled_tags << @prefixed_tags['prefix_paragraph']
+          @enabled_tags << @prefixed_tags['prefix_newline']
+          template.render(@context).should == expected_output
+        end
+
+        it 'uses render_disabled or empty string if the plugin is not enabled' do
+          expected_output = <<-TEMPLATE
+            Some Text
+            Some Text
+          TEMPLATE
+
+          register_tags(@prefixed_tags)
+          template = ::Liquid::Template.parse(@raw_template)
+          template.render(@context).should == expected_output
+        end
+
+        it 'uses render_disabled or empty string if no plugin is enabled' do
+          @context.registers.delete(:enabled_plugin_tags)
+
+          expected_output = <<-TEMPLATE
+            Some Text
+            Some Text
+          TEMPLATE
+
+          register_tags(@prefixed_tags)
+          template = ::Liquid::Template.parse(@raw_template)
+          template.render(@context).should == expected_output
+        end
+
+        protected
+
+        def register_tags(tags)
+          tags.each do |name, klass|
+            ::Liquid::Template.register_tag(name, klass)
+          end
+        end
+
+      end
+
+    end
+  end
+end