skylinecms 3.0.8 → 3.1.0

data/lib/skyline/plugins_manager.rb

@@ -2,28 +2,149 @@
 # static as it can only load plugins from `Rails.root/vendor/skyline_plugins`. As
 # we extend the Plugin API the manager will become more advanced.
 # 
+# The pluginmanager sets up the following for you:
+# 
+# * Public path (PLUGIN/public/PLUGIN_NAME)
+# * Routes (PLUGIN/config/routes.rb)
+# * View path (PLUGIN/app/views)
+# * Load paths (PLUGIN/app/controllers, PLUGIN/app/models, PLUGIN/app/helpers)
+# * Locales (PLUGIN/config/locales/*.{yml,rb})
+# 
+# The pluginmanager will also load: `PLUGIN/skyline/init.rb` on intialization (after it sets up the above paths)
+# And the pluginmanager will run `PLUGIN/skyline/load.rb` on every request (in development mode)
+# 
 # @private
 class Skyline::PluginsManager
   class << self
+    
+    # Initialize all plugins
     def init_all!
-      public_skyline_plugins_path = Pathname.new(Rails.public_path) + "skyline_plugins"
-      FileUtils.mkdir(public_skyline_plugins_path) unless public_skyline_plugins_path.exist?
-            
-      # Initialize external skyline plugins (only once)
-      Dir[Rails.root + "vendor/skyline_plugins/*/skyline/init.rb"].each do |file|
-        load file
-      end
+      FileUtils.mkdir(self.public_path) unless self.public_path.exist?
+
+      self.plugins.each{|path, plugin| plugin.init! }
     end
-        
+
+    # Load all plugins
     def load_all!
-      # Load external skyline plugins (possibly at every request)
-      Dir[Rails.root + "vendor/skyline_plugins/*/skyline/load.rb"].each do |file|
-        load file
-      end      
+      self.plugins.each{|path, plugin| plugin.load! }  
+    end
+    
+    # The path where all skyline plugins reside
+    # 
+    # @return [Pathname] Path of the plugins
+    def plugin_path
+      Rails.root + "vendor/skyline_plugins"
+    end
+    
+    # The path where all public plugin assets reside
+    # 
+    # @return [Pathname] Rails.public_path + "skyline_plugins"
+    def public_path
+      Pathname.new(Rails.public_path) + "skyline_plugins"
+    end
+
+    # All known plugins
+    #
+    # @param [Boolean] force_reload (false) Forcefully reload the plugin directories
+    # 
+    # @return [Array[PluginsManager]] An array of plugins
+    def plugins(force_reload = false)
+      return @plugins if @plugins && !force_reload
+      @plugins ||= {}
+      Dir[self.plugin_path + "*"].each do |path|
+        @plugins[path] = self.new(path) if self.valid_plugin?(path) && !@plugins.has_key?(path)
+      end
+      @plugins
+    end
+    
+    # Does the path contain a valid plugin?
+    #
+    # @param [String] path Path of a plugin
+    # 
+    # @return [Boolean] 
+    def valid_plugin?(path)
+      p = Pathname.new(path)
+      p.directory?
     end
+  end
+  
+  attr_reader :name, :path, :init_file, :load_file, :migration_path, :seed_path
+  
+  def initialize(path)
+    @path = Pathname.new(path)
+    @name = @path.basename.to_s
+    
+    files = { 
+      :init_file => "skyline/init.rb",
+      :load_file => "skyline/load.rb",
+      :migration_path => "db/migrate",
+      :seed_path => "db/fixtures" 
+    }
     
-    def migration_paths
-      Dir[Rails.root + "vendor/skyline_plugins/*/db/migrate"]
+    files.each do |key, path|
+      
+      f = @path + path
+      instance_variable_set("@#{key}",f) if f.exist?
     end
   end
+  
+  # Initialize the plugin, this is usually done just once when the server starts
+  def init!
+    add_routes!
+    add_load_paths!
+    add_view_path!
+    add_public_path!
+    add_locales!
+
+    load(@init_file) if @init_file
+  end
+  
+  # Load the plugin, this will be done on every request in development
+  # only once in production mode.
+  def load!
+    load(@load_file) if @load_file
+  end
+    
+  protected
+  
+  def add_routes!
+    rp = (self.path + "config/routes.rb")
+    return unless rp.exist?
+    ActionController::Routing::Routes.configuration_files = [rp.to_s] + ActionController::Routing::Routes.configuration_files
+    ActionController::Routing::Routes.reload!
+  end
+  
+  def add_load_paths!
+    %w{app/models app/controllers app/helpers}.each do |p|
+      pn = self.path + p
+      ActiveSupport::Dependencies.load_paths << pn.to_s if pn.exist?
+    end
+  end
+  
+  def add_view_path!
+    vp = (self.path + "app/views")
+    ActionController::Base.view_paths << vp.to_s if vp.exist?
+  end
+  
+  def add_public_path!
+    plugin_public_path = self.path + "public/#{self.name}"
+    return unless plugin_public_path.exist?
+      
+    public_path = self.class.public_path + self.name
+    unless public_path.exist?
+      FileUtils.rm(public_path) if public_path.symlink?
+    
+      puts "=> Skyline [Plugin: #{self.name}]: Creating assets symlink to '#{public_path}'"
+      FileUtils.ln_s(plugin_public_path.relative_path_from(self.class.public_path), public_path)
+    end    
+  end
+  
+  def add_locales!
+    plugin_locales = Dir[self.path + "config/locales/*.{yml,rb}"]
+    return unless plugin_locales.present?
+    
+    idx = I18n.load_path.index(I18n.load_path.grep(/#{Rails.root}\/config\/locales.+/).first)
+    I18n.load_path.insert(idx, *plugin_locales) 
+  end
+  
 end

data/lib/skyline/rendering/helpers/renderer_helper.rb

@@ -26,42 +26,42 @@ module Skyline::Rendering
 
       # Get's the current Renderer instance that is rendering the template we're in.
       # 
-      # @return [Skyline::Renderer] The renderer
+      # @return [Skyline::Rendering::Renderer] The renderer
       def renderer
         @_renderer
       end
 
-      # @see Skyline::Renderer#render
+      # @see Skyline::Rendering::Renderer#render
       def render_object(object, options = {})
         renderer.render(object, options)
       end
 
-      # @see Skyline::Renderer#render_collection
+      # @see Skyline::Rendering::Renderer#render_collection
       def render_collection(objects, options = {},&block)
         renderer.render_collection(objects, options, &block)
       end
 
-      # @see Skyline::Renderer#peek
+      # @see Skyline::Rendering::Renderer#peek
       def peek(n=1, &block)
         renderer.peek(n, &block)
       end
 
-      # @see Skyline::Renderer#peek_until} 
+      # @see Skyline::Rendering::Renderer#peek_until} 
       def peek_until(&block)
         renderer.peek_until(&block)
       end
 
-      # @see Skyline::Renderer#render_until
+      # @see Skyline::Rendering::Renderer#render_until
       def render_until(&block)
         renderer.render_until(&block)
       end    
 
-      # @see Skyline::Renderer#skip!
+      # @see Skyline::Rendering::Renderer#skip!
       def skip!(n=1)
         renderer.skip!(n)
       end
 
-      # @see Skyline::Renderer#skip_until!
+      # @see Skyline::Rendering::Renderer#skip_until!
       def skip_until!(&block)
         renderer.skip_until!(&block)
       end
@@ -91,6 +91,11 @@ module Skyline::Rendering
       def flash
         @_controller.send(:flash)
       end
+      
+      # The controller
+      def controller
+        @_controller
+      end
 
       # The site that's currently in scope for this template
       #
@@ -137,7 +142,7 @@ module Skyline::Rendering
       # Simple, quick 'n dirty solution so you can use 'acticle_version', 'news_item', .. in all 
       # your templates. So you don't have to use @.... or pass the local to all partials.
       # 
-      # @private
+      # @deprecated Don't use the name of the object anymore,  use `renderer.object` instead.
       def method_missing(method, *params, &block)
         return @_local_object if @_local_object_name == method
         super

data/lib/skyline/{renderer.rb → rendering/renderer.rb}

@@ -1,6 +1,6 @@
 # The skyline renderer renders all Articles, Sections and basically anything that's renderable
 # or previewable in Skyline.
-class Skyline::Renderer
+class Skyline::Rendering::Renderer
   attr_reader :assigns, :template_paths
   attr_accessor :_config
   
@@ -222,7 +222,7 @@ class Skyline::Renderer
     return [] if @_current_collection.blank?
     items = @_current_collection[@_current_collection_index + @_collection_skip + 1 .. -1]
     return [] unless items
-    item.each do |i|
+    items.each do |i|
       return if yield i
       skip!    
     end
@@ -333,7 +333,7 @@ class Skyline::Renderer
     template_paths = []
     @template_paths.each do |root|
       Dir.chdir(root) do
-        template_paths = template_paths | Dir.glob("#{path}/*").select{|d| File.directory?(d)  }.map{|d| File.basename(d)}
+        template_paths = template_paths | Dir.glob("#{path}/*/index.*").map{|d| File.dirname(d) }.select{|d| File.directory?(d)  }.map{|d| File.basename(d)}
       end
     end
     template_paths
@@ -370,7 +370,6 @@ class Skyline::Renderer
   module Helpers
     include Skyline::Rendering::Helpers::ColumnHelper
     include Skyline::Rendering::Helpers::BreadCrumbHelper
-    include Skyline::Rendering::Helpers::SettingsHelper    
     
     def helper(module_name)
       return self.send(:include,module_name) if module_name == Module

data/lib/skyline/{renderable_scope_interface.rb → rendering/scopes/interface.rb}

@@ -1,6 +1,6 @@
 # @abstract Implement this interface in classes that can be used
 #   as renderable scopes.
-module Skyline::RenderableScopeInterface
+module Skyline::Rendering::Scopes::Interface
   
   # @abstract
   def renderer(options = {})

data/lib/skyline/{wildcard_renderable_scope.rb → rendering/scopes/wildcard.rb}

@@ -1,9 +1,9 @@
 # @private
-class Skyline::WildcardRenderableScope
-  include Skyline::RenderableScopeInterface
+class Skyline::Rendering::Scopes::Wildcard
+  include Skyline::Rendering::Scopes::Interface
 
   def renderer(options = {})
-    Skyline::Renderer.new(options)
+    Skyline::Rendering::Renderer.new(options)
   end
     
   def serialize

data/lib/skyline/{section_item.rb → sections/interface.rb}

@@ -1,19 +1,26 @@
-# Defines the SectionItem interface. Include this module in all your sections.
+# Defines the section interface. Include this module in all your sections.
 #
 # If you're creating your Section within the Skyline module (you probably shouldn't), it
 # will automatically sets your models table name to `skyline_sections_#{base.table_name}`
 #
 # @example Usage: 
-#   class Model < ActiveRecord::Base
-#     include Skyline::SectionItem
-#   end
-#
-# @example Defines:
-#   Model.default_interface = true # defaults to true
-#   @model = Model.new
-#   @model.to_text #=> ""
+# 
+# class Model < ActiveRecord::Base
+#   include Skyline::Sections::Interface
+# end
 #
-module Skyline::SectionItem 
+# @example Defines the following interface:
+# 
+# class Model < ActiveRecord::Base
+#   has_one :section, :as => :sectionable, :class_name => "Skyline::Section" # The link back to the section
+#   self.default_interface = true # defaults to true
+#   
+#   def to_text
+#     ...
+#   end
+# end
+# 
+module Skyline::Sections::Interface
  
   def self.included(base)
     base.class_eval do

data/lib/skyline/settings.rb

@@ -1,11 +1,11 @@
 module Skyline::Settings
   
   def self.included(obj)
-    obj.extend(KlassMethods)
+    obj.extend(ClassMethods)
     obj.send(:serialize, :data)
   end  
   
-  module KlassMethods
+  module ClassMethods
     
     # Define a page in the object, see example below
     #
@@ -62,15 +62,13 @@ module Skyline::Settings
       f
     end
     
-    # a safe way to get a value of a setting and report a warning if it can't be found     #
-    #  instead of calling Setting[:setting_identifier].field directly use setting(:setting_identifier, :field)
-    # ==== Parameters
-    # setting_identifier<Symbol>:: the symbol of the settings page
-    # field<Symbol>:: the name of the setting
-    #
-    # ==== Returns
-    # Object:: the value of the setting or nil if not found
-    # --
+    # A safe way to get a value of a setting and report a warning if it can't be found  
+    # instead of calling Setting[:setting_identifier].field directly use setting(:setting_identifier, :field)
+    # 
+    # @param setting_identifier [Symbol] the symbol of the settings page
+    # @param field [Symbol] the name of the setting
+    # 
+    # @return [Object] the value of the setting or nil if not found
     def get(setting_identifier, field)
       if s = self[setting_identifier]
         if s.respond_to?(field)
@@ -81,14 +79,12 @@ module Skyline::Settings
       nil
     end
     
-    # a safe way to get a page from the settings     
-    # ==== Parameters
-    # setting_identifier<Symbol>:: the symbol of the settings page
-    # field<Symbol>:: the name of the setting that references a page_id
-    #
-    # ==== Returns
-    # Page:: the page if found or nil otherwise
-    # --
+    # a safe way to get a page from the settings  
+    # 
+    # @param setting_identifier [Symbol] the symbol of the settings page
+    # @param field [Symbol] the name of the setting that references a page_id
+    # 
+    # @return [Page, NilClass] The page if found, nil otherwise
     def get_page(setting_identifier, field)
       if page_id = self.get(setting_identifier, field)
         return Skyline::Page.find_by_id(page_id) if page_id.present?
@@ -96,6 +92,20 @@ module Skyline::Settings
       nil
     end
     
+    # Can be used to reference a Page/MediaFile etc directly. Sets it
+    # to `FIELD_id`.
+    # 
+    # @param field [String,Symbol] The field name to use (multiple possible)
+    def referable_serialized_content(*fields)
+      fields.each do |f|
+        self.class_eval <<-END
+          def #{f}_attributes=(attr)
+            self.#{f}_id = attr[:referable_id]
+          end
+        END
+      end
+    end    
+    
     protected
     
     def page_cache

data/lib/skyline/taggable.rb

@@ -33,7 +33,7 @@ module Skyline::Taggable
     base.class_eval do
       named_scope :with_tags, lambda {|tags|
         if tags.any?
-          {:conditions => tags.collect{|tag| "#{tag.id} IN (SELECT tag_id FROM skyline_associated_tags WHERE taggable_id=#{self.table_name}.id AND taggable_type='#{self.name}')"}.join(" OR "),
+          {:conditions => ["(SELECT tag_id FROM skyline_associated_tags WHERE taggable_id=#{self.table_name}.id AND taggable_type=? AND tag_id IN (?) LIMIT 1)", self.name, tags],
            :include => :associated_tags}
         else
           {}
@@ -61,9 +61,9 @@ module Skyline::Taggable
   end
   
   def clone_with_associated_tags
-    returning clone_without_associated_tags do |clone|      
+    clone_without_associated_tags.tap{|clone|      
       clone.associated_tags = self.associated_tags.collect{|at| at.clone }
-    end
+    }
   end  
   
   protected

data/lib/skyline/version.rb

@@ -5,8 +5,8 @@ module Skyline
   # @private
   module VERSION
     MAJOR = 3
-    MINOR = 0
-    TINY = 8
+    MINOR = 1
+    TINY = 0
     BUILD = 0
 
     # Some hackery to determine if we're on a development branch or not

data/{tasks → lib/tasks}/database.rake

@@ -7,8 +7,12 @@ namespace :skyline do
       ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
       ActiveRecord::Migrator.migrate(Skyline.root + "db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
       
-      Skyline::PluginsManager.migration_paths.each do |dir|
-        ActiveRecord::Migrator.migrate(dir, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+      # Also seed plugins
+      Skyline::PluginsManager.plugins.each do |path, plugin|
+        next unless plugin.migration_path
+        
+        puts "\n\n[PLUGIN] [#{plugin.name}] ============================="
+        ActiveRecord::Migrator.migrate(plugin.migration_path, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
       end      
       
       Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby      
@@ -59,6 +63,14 @@ namespace :skyline do
       Dir[Skyline.root + "db/fixtures/*.rb"].each do |f|
         load f
       end
+      
+      # Also seed plugins
+      Skyline::PluginsManager.plugins.each do |path, plugin|
+        puts "\n\n[PLUGIN] [#{plugin.name}] ============================="
+        Dir[plugin.seed_path + "*.rb"].each do |f|
+          load f
+        end
+      end
     end
     
   end

data/lib/tasks/testing.rake

@@ -0,0 +1,41 @@
+namespace :skyline do
+
+  desc 'Run all unit, functional and integration tests'
+  task :test do
+    errors = %w(skyline:test:units skyline:test:functionals skyline:test:integration).collect do |task|
+      begin
+        Rake::Task[task].invoke
+        nil
+      rescue => e
+        task
+      end
+    end.compact
+    abort "Errors running #{errors.to_sentence(:locale => :en)}!" if errors.any?
+  end
+  
+  namespace :test do
+    Rake::TestTask.new(:units => [:environment,"db:test:prepare"]) do |t|
+      base = File.join(File.dirname(__FILE__), "../..")
+      t.libs << (base + "/test")
+      t.pattern =  base + '/test/unit/**/*_test.rb'
+      t.verbose = true
+    end
+    Rake::Task['test:units'].comment = "Run the unit tests in test/unit"
+
+    Rake::TestTask.new(:functionals => "db:test:prepare") do |t|
+      base = File.join(File.dirname(__FILE__), "../..")      
+      t.libs << (base + "/test")
+      t.pattern =  base + '/test/functional/**/*_test.rb'
+      t.verbose = true
+    end
+    Rake::Task['test:functionals'].comment = "Run the functional tests in test/functional"
+
+    Rake::TestTask.new(:integration => "db:test:prepare") do |t|
+      base = File.join(File.dirname(__FILE__), "../..")      
+      t.libs << (base + "/test")
+      t.pattern =  base + '/test/integration/**/*_test.rb'
+      t.verbose = true
+    end
+    Rake::Task['test:integration'].comment = "Run the integration tests in test/integration"    
+  end
+end