Get sample web working with plugins

dotless · Feb 17, 2012 · 22f8fb0 · 22f8fb0
1 parent b92a68d
commit 22f8fb0
Show file tree

Hide file tree

Showing 13 changed files with 109 additions and 25 deletions.
diff --git a/src/dotless.Compiler/Program.cs b/src/dotless.Compiler/Program.cs
@@ -176,7 +176,7 @@ private static IEnumerable<IPluginConfigurator> GetPluginConfigurators()
         {
             if (_pluginConfigurators == null)
             {
-                _pluginConfigurators = PluginFinder.GetConfigurators(true, false);
+                _pluginConfigurators = PluginFinder.GetConfigurators(true);
             }
             return _pluginConfigurators;
         }
@@ -230,7 +230,7 @@ private static void WriteHelp()
 
         private static CompilerConfiguration GetConfigurationFromArguments(List<string> arguments)
         {
-            var configuration = new CompilerConfiguration(DotlessConfiguration.Default);
+            var configuration = new CompilerConfiguration(DotlessConfiguration.GetDefault());
 
             foreach (var arg in arguments)
             {

diff --git a/src/dotless.Core/ContainerFactory.cs b/src/dotless.Core/ContainerFactory.cs
@@ -13,6 +13,7 @@ namespace dotless.Core
     using Stylizers;
     using dotless.Core.Plugins;
     using System.Collections.Generic;
+    using dotless.Core.Importers;
 
     public class ContainerFactory
     {
@@ -74,6 +75,8 @@ private void RegisterCoreServices(FluentRegistration pandora, DotlessConfigurati
             pandora.Service<LogLevel>("error-level").Instance(configuration.LogLevel);
             pandora.Service<IStylizer>().Implementor<PlainStylizer>();
 
+            pandora.Service<IImporter>().Implementor<Importer>();
+
             pandora.Service<Parser.Parser>().Implementor<Parser.Parser>().Parameters("optimization").Set("default-optimization").Lifestyle.Transient();
             pandora.Service<int>("default-optimization").Instance(configuration.Optimization);
 

diff --git a/src/dotless.Core/Engine/LessEngine.cs b/src/dotless.Core/Engine/LessEngine.cs
@@ -8,6 +8,7 @@ namespace dotless.Core
     using Loggers;
     using Parser.Infrastructure;
     using Parser.Tree;
+    using System.IO;
 
     public class LessEngine : ILessEngine
     {

diff --git a/src/dotless.Core/EngineFactory.cs b/src/dotless.Core/EngineFactory.cs
@@ -10,7 +10,7 @@ public EngineFactory(DotlessConfiguration configuration)
         {
             Configuration = configuration;
         }
-        public EngineFactory() : this(DotlessConfiguration.Default)
+        public EngineFactory() : this(DotlessConfiguration.GetDefault())
         {
         }
 

diff --git a/src/dotless.Core/HandlerImpl.cs b/src/dotless.Core/HandlerImpl.cs
@@ -24,7 +24,7 @@ public void Execute()
             var localPath = Http.Context.Request.Url.LocalPath;
 
             var source = FileReader.GetFileContents(localPath);
-
+            
             Response.WriteCss(Engine.TransformToCss(source, localPath));
         }
     }

diff --git a/src/dotless.Core/Less.cs b/src/dotless.Core/Less.cs
@@ -6,7 +6,7 @@ public static class Less
     {
         public static string Parse(string less)
         {
-            return Parse(less, DotlessConfiguration.Default);
+            return Parse(less, DotlessConfiguration.GetDefault());
         }
 
         public static string Parse(string less, DotlessConfiguration config)

diff --git a/src/dotless.Core/Plugins/GenericPluginConfigurator.cs b/src/dotless.Core/Plugins/GenericPluginConfigurator.cs
@@ -40,7 +40,7 @@ public void SetParameterValues(IEnumerable<IPluginParameter> pluginParameters)
             ConstructorInfo parameterConstructor;
             GetConstructorInfos(out parameterConstructor, out defaultConstructor);
 
-            if (pluginParameters == null || pluginParameters.Count() == 0 || pluginParameters.Any(parameter => parameter.Value == null))
+            if (pluginParameters == null || pluginParameters.Count() == 0 || pluginParameters.All(parameter => parameter.Value == null))
             {
                 if (defaultConstructor == null)
                 {
@@ -52,7 +52,19 @@ public void SetParameterValues(IEnumerable<IPluginParameter> pluginParameters)
             {
                 var constructorArguments = parameterConstructor.GetParameters()
                     .OrderBy(parameter => parameter.Position)
-                    .Select(parameter => pluginParameters.First(pluginParameter => pluginParameter.Name == parameter.Name).Value)
+                    .Select(parameter => 
+                    {
+                        var p = pluginParameters.FirstOrDefault(pluginParameter => pluginParameter.Name == parameter.Name);
+                        if (p == null)
+                        {
+                            if (parameter.ParameterType.IsValueType) 
+                            {
+                                return Activator.CreateInstance(parameter.ParameterType);
+                            }
+                            return null;
+                        }
+                        return p.Value;
+                    })
                     .ToArray();
 
                 _pluginCreator = () => (T)parameterConstructor.Invoke(constructorArguments);

diff --git a/src/dotless.Core/Plugins/PluginFinder.cs b/src/dotless.Core/Plugins/PluginFinder.cs
@@ -61,18 +61,11 @@ public static string GetName(Type pluginType)
         ///  a plugins folder underneath the executing assembly
         /// </summary>
         /// <param name="scanPluginsFolder">Look for a plugins folder and if exists, load plugins from it</param>
-        /// <param name="scanLoadedDlls">Whether to look at referenced dll's and scan them for plugins</param>
         /// <returns></returns>
-        public static IEnumerable<IPluginConfigurator> GetConfigurators(bool scanPluginsFolder, bool scanLoadedDlls)
+        public static IEnumerable<IPluginConfigurator> GetConfigurators(bool scanPluginsFolder)
         {
             List<IEnumerable<IPluginConfigurator>> pluginConfigurators = new List<IEnumerable<IPluginConfigurator>>();
 
-            if (scanLoadedDlls) 
-            {
-                pluginConfigurators.AddRange(Assembly.GetEntryAssembly().GetReferencedAssemblies()
-                    .Select(assembly => GetConfigurators(Assembly.Load(assembly))));
-            }
-
             pluginConfigurators.Add(GetConfigurators(Assembly.GetAssembly(typeof(PluginFinder))));
 
             if (scanPluginsFolder)
@@ -108,12 +101,12 @@ public static IEnumerable<IPluginConfigurator> GetConfigurators(Assembly assembl
 
             IEnumerable<Type> pluginsConfigurated = pluginConfigurators.Select(pluginConfigurator => pluginConfigurator.Configurates);
 
-            Type genericPluginConfiguratorType = typeof(GenericPluginConfigurator<IPlugin>).GetGenericTypeDefinition();
+            Type genericPluginConfiguratorType = typeof(GenericPluginConfigurator<>);
 
             IEnumerable<IPluginConfigurator> plugins = types
                 .Where(type => typeof(IPlugin).IsAssignableFrom(type))
                 .Where(type => !pluginsConfigurated.Contains(type))
-                .Select(type => (IPluginConfigurator)genericPluginConfiguratorType.MakeGenericType(type).GetConstructor(new Type[]{}).Invoke(new object[]{}));
+                .Select(type => (IPluginConfigurator)Activator.CreateInstance(genericPluginConfiguratorType.MakeGenericType(type)));
 
             return plugins.Union(pluginConfigurators);
         }

diff --git a/src/dotless.Core/configuration/DotlessConfiguration.cs b/src/dotless.Core/configuration/DotlessConfiguration.cs
@@ -3,16 +3,23 @@ namespace dotless.Core.configuration
     using System;
     using Input;
     using Loggers;
-using dotless.Core.Plugins;
-using System.Collections.Generic;
+    using dotless.Core.Plugins;
+    using System.Collections.Generic;
 
     public class DotlessConfiguration
     {
-        public static readonly DotlessConfiguration Default = new DotlessConfiguration();
-        public static readonly DotlessConfiguration DefaultWeb = new DotlessConfiguration
+        public static DotlessConfiguration GetDefault()
+        {
+            return new DotlessConfiguration();
+        }
+
+        public static DotlessConfiguration GetDefaultWeb()
+        {
+            return new DotlessConfiguration
             {
                 Web = true
             };
+        }
 
         public DotlessConfiguration()
         {

diff --git a/src/dotless.Core/configuration/DotlessConfigurationSectionHandler.cs b/src/dotless.Core/configuration/DotlessConfigurationSectionHandler.cs
@@ -8,7 +8,7 @@ public class DotlessConfigurationSectionHandler : IConfigurationSectionHandler
     {
         public object Create(object parent, object configContext, XmlNode section)
         {
-            var configuration = DotlessConfiguration.Default;
+            var configuration = DotlessConfiguration.GetDefault();
 
             try
             {

diff --git a/src/dotless.Core/configuration/WebConfigConfigurationLoader.cs b/src/dotless.Core/configuration/WebConfigConfigurationLoader.cs
@@ -9,7 +9,7 @@ public DotlessConfiguration GetConfiguration()
             var webconfig = (DotlessConfiguration)ConfigurationManager.GetSection("dotless");
 
             if (webconfig == null)
-                return DotlessConfiguration.DefaultWeb;
+                return DotlessConfiguration.GetDefaultWeb();
 
             webconfig.Web = true;
 

diff --git a/src/dotless.Core/configuration/XmlConfigurationInterpreter.cs b/src/dotless.Core/configuration/XmlConfigurationInterpreter.cs
@@ -3,12 +3,16 @@ namespace dotless.Core.configuration
     using System;
     using System.Xml;
     using Loggers;
+    using dotless.Core.Plugins;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
 
     public class XmlConfigurationInterpreter
     {
         public DotlessConfiguration Process(XmlNode section)
         {
-            var dotlessConfiguration = DotlessConfiguration.DefaultWeb;
+            var dotlessConfiguration = DotlessConfiguration.GetDefaultWeb();
 
             dotlessConfiguration.MinifyOutput = GetBoolValue(section, "minifyCss") ?? dotlessConfiguration.MinifyOutput;
             dotlessConfiguration.CacheEnabled = GetBoolValue(section, "cache") ?? dotlessConfiguration.CacheEnabled;
@@ -40,6 +44,7 @@ public DotlessConfiguration Process(XmlNode section)
                 dotlessConfiguration.LessSource = source;
 
             dotlessConfiguration.Logger = GetTypeValue(section, "logger");
+            dotlessConfiguration.Plugins.AddRange(GetPlugins(section));
 
             return dotlessConfiguration;
         }
@@ -96,5 +101,63 @@ private static Type GetTypeValue(XmlNode section, string property)
 
             return null;
         }
+
+        private static IEnumerable<IPluginConfigurator> GetPlugins(XmlNode section)
+        {
+            List<IPluginConfigurator> plugins = new List<IPluginConfigurator>();
+            IEnumerable<IPluginConfigurator> dotlessPlugins = null; //lazy initiate incase of no plugins used
+            List<string> assemblies = new List<string>();
+
+            foreach (XmlNode node in section.SelectNodes("plugin"))
+            {
+                if (dotlessPlugins == null)
+                {
+                    dotlessPlugins = PluginFinder.GetConfigurators(false);
+                }
+
+                string assembly = GetStringValue(node, "assembly");
+
+                if (assembly != null)
+                {
+                    if (!assemblies.Contains(assembly)) {
+                        dotlessPlugins = dotlessPlugins.Union(PluginFinder.GetConfigurators(Assembly.Load(assembly)));
+                        assemblies.Add(assembly);
+                    }
+                }
+
+                string name = GetStringValue(node, "name");
+                var plugin = dotlessPlugins.Where(p => p.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))
+                    .FirstOrDefault();
+
+                if (plugin == null)
+                {
+                    throw new Exception(
+                        string.Format("Cannot find plugin called {0}. If it is an external plugin, make sure the assembly is referenced.", name));
+                }
+                var pluginParameters = plugin.GetParameters();
+
+                foreach (XmlNode pluginParameter in node.SelectNodes("pluginParameter"))
+                {
+                    var pluginParameterName = GetStringValue(pluginParameter, "name");
+                    var pluginParameterValue = GetStringValue(pluginParameter, "value");
+
+                    var actualParameter = pluginParameters
+                        .Where(p => p.Name.Equals(pluginParameterName, StringComparison.InvariantCultureIgnoreCase))
+                        .FirstOrDefault();
+
+                    if (actualParameter == null)
+                    {
+                        throw new Exception(
+                            string.Format("Cannot find plugin argument {0} in plugin {1}", pluginParameterName, name));
+                    }
+
+                    actualParameter.SetValue(pluginParameterValue);
+                }
+
+                plugin.SetParameterValues(pluginParameters);
+                plugins.Add(plugin);
+            }
+            return plugins;
+        }
     }
 }
diff --git a/src/dotless.SampleWeb/Content/Web.config b/src/dotless.SampleWeb/Content/Web.config
@@ -4,7 +4,12 @@
     <section name="dotless" type="dotless.Core.configuration.DotlessConfigurationSectionHandler,dotless.Core" />
   </configSections>
 
-  <dotless minifyCss="true" cache="false" />
+  <dotless minifyCss="true" cache="false">
+    <plugin name="Rtl">
+      <pluginParameter name="onlyReversePrefixedRules" value="false" />
+      <pluginParameter name="forceRtlTransform" value="false" />
+    </plugin>      
+  </dotless>
 
   <system.web>
     <httpHandlers>