skylinecms 3.1.0 → 3.2.0

data/lib/skyline/cli/init/templates/config/initializers/skyline_configuration.rb

@@ -1,5 +1,4 @@
 Skyline::Configuration.configure do |config|  
   config.assets_path = File.join(Rails.root,"tmp/upload")
   config.media_file_cache_path = File.join(Rails.root,"tmp/cache/media_files/cache")
-  config.rss_section_cache_path = File.join(Rails.root,"tmp/cache/rss_sections/cache")
 end

data/lib/skyline/configuration.rb

@@ -6,57 +6,80 @@
 class Skyline::Configuration < Configure
   
   defaults do |config|
+    # The application name (defaults to the name)
     config.name = File.expand_path(Rails.root).split("/").last
+    
+    # The application title
     config.title = config.name.humanize
     
-    config.sections = {:default => [
-                         "wysiwyg_section", 
-                         "heading_section", 
-                         "rss_section", 
-                         "iframe_section",
-                         "content_collection_section", 
-                         "content_item_section", 
-                         "splitter_section", 
-                         "link_section",
-                         "raw_section",
-                         "media_section",
-                         "redirect_section",
-                         "page_fragment_section"]
-                      }
+    # Available sections per article
+    config.sections = {
+      :default => [
+        "wysiwyg_section", 
+        "heading_section", 
+        "rss_section", 
+        "iframe_section",
+        "content_collection_section", 
+        "content_item_section", 
+        "splitter_section", 
+        "link_section",
+        "raw_section",
+        "media_section",
+        "redirect_section",
+        "page_fragment_section"
+      ]
+    }
     
+    # Available articles (Skyline::Page is always included)
     config.articles = []
-    config.content_classes = []
     
-    config.rss_section_cache_timeout = 1.hour  
+    # Available content classes
+    config.content_classes = []
     
+    # Do you want to use a custom logo? If so define it here    
     config.custom_logo = false
     config.skyline_logo = "/skyline/images/logo.png"
+    
+    # Add a "branding" name so you don't have to use the name "Skyline"
     config.branding_name = ""
     
+    # The Skyline locale
     config.locale = "en-US"
     
+    # Custom stylesheets to include
     # ie: [{:path => "/stylesheets/skyline.css", :if => "lte IE 7"}]
     config.custom_stylesheets = []
     
+    # Path configuration
     if Rails.env == "production"
       config.assets_path = nil
       config.media_file_cache_path = nil
+      
+      # Only if you need the rss section
       config.rss_section_cache_path = nil
     else
-      config.assets_path = File.join(Rails.root,"/tmp/upload")
-      config.media_file_cache_path = File.join(Rails.root,"/tmp/media_files/cache")
-      config.rss_section_cache_path = File.join(Rails.root,"/tmp/rss_sections/cache")
+      config.assets_path = Rails.root + "tmp/upload"
+      config.media_file_cache_path = Rails.root + "tmp/media_files/cache"
+      
+      # Only if you need the rss section      
+      config.rss_section_cache_path = Rails.root + "tmp/rss_sections/cache"
     end 
-    
-    unless ActiveSupport::Dependencies.load_once_path?(__FILE__)
-      # We need to reload the configuration because this file get's reloaded 
-      if (Rails.root + "config/initializers/skyline_configuration.rb").exist?
-        load Rails.root + "config/initializers/skyline_configuration.rb"
-      end    
-    end
+        
+    # Authentication User model
+    config.user_class = Skyline::User
     
     # Default URL admin prefix (default = /skyline/...)
-    config.url_prefix = "/skyline"
+    config.url_prefix = "skyline"
+    
+    # The skyline_root default route.
+    # Most unfortunately we have to set it like this because we cannot override a specific route from the plugin
+    # in the implementation.    
+    config.default_route = {:to => "articles#index", :type => "skyline/page"}
+    
+    # The skyline_root default route.
+    # Most unfortunately we have to set it like this because we cannot override a specific route from the plugin
+    # in the implementation.
+    config.default_route = {:controller => "articles", :action => "index", :type => "skyline/page"}
     
     # enable/disable 'modules'
     config.enable_pages = true
@@ -64,17 +87,28 @@ class Skyline::Configuration < Configure
     config.enable_locking = true
     config.enable_enforce_only_one_user_editing = true
     config.enable_publication_history = true
+    
+    # Section stuff
+    config.rss_section_cache_timeout = 1.hour
+    
+    # We need to reload the configuration if this file get's reloaded 
+    unless ActiveSupport::Dependencies.load_once_path?(__FILE__)
+      if (Rails.root + "config/initializers/skyline_configuration.rb").exist?
+        load Rails.root + "config/initializers/skyline_configuration.rb"
+      end    
+    end    
   end  
   
   def after_configure
-    check_or_create_path(self["assets_path"],"assets_path")
-    check_or_create_path(self["media_file_cache_path"],"media_file_cache_path")
-    check_or_create_path(self["rss_section_cache_path"],"rss_section_cache_path")
+    sanitize_paths
     
     Skyline::MediaNode.assets_path = self["assets_path"]  
     Skyline::MediaCache.cache_path = self["media_file_cache_path"]
-    Skyline::Sections::RssSection.cache_path = self["rss_section_cache_path"]
-    Skyline::Sections::RssSection.cache_timeout = self["rss_section_cache_timeout"]
+    
+    if self.sections.values.flatten.uniq.include?("rss_section")
+      Skyline::Sections::RssSection.cache_path = self["rss_section_cache_path"]
+      Skyline::Sections::RssSection.cache_timeout = self["rss_section_cache_timeout"]
+    end
     
     Skyline::Rendering::Renderer.register_renderables(:sections,self["sections"])
     Skyline::Rendering::Renderer.register_renderables(:articles,self["articles"] + ["Skyline::Page"])      
@@ -93,6 +127,14 @@ class Skyline::Configuration < Configure
   end
   
   protected
+  
+  # Ensures that all paths are Pathname objects
+  def sanitize_paths
+    %w{assets_path media_file_cache_path}.each do |key|
+      self[key] = Pathname.new(self[key]) if self[key] && !self[key].kind_of?(Pathname)
+      check_or_create_path(self[key], key)
+    end    
+  end
     
   # Check if a path is set, and if we're in production made raise an assertion
   # if the path does not exist. It just creates the path in development mode.

data/lib/skyline/content/content.rb

@@ -8,7 +8,7 @@ module Skyline::Content
          obj.class_eval do 
            after_save :process_after_save
            
-           named_scope :published, lambda {
+           scope :published, lambda {
              if obj.publishable?
                {:conditions => {:published => true}}
              else
@@ -16,7 +16,7 @@ module Skyline::Content
              end
            }
 
-           named_scope :with_site, {}
+           scope :with_site, {}
          end         
        end
      end 
@@ -100,7 +100,7 @@ module Skyline::Content
       # Same as find_for_cms, but works with the will_paginate plugin
       #--
       def paginate_for_cms(*args)
-        skyline_options,options = extract_all_options!(args)        
+        skyline_options, options = extract_all_options!(args)        
         with_skyline_scope(skyline_options) do
          options.update(:order => self.default_order_by_statement)
          paginate(*(args << options))
@@ -218,8 +218,8 @@ module Skyline::Content
      def relate_to(obj) # :nodoc:
        return unless assoc = obj.class.reflect_on_association(self.instantiated_by)
        case assoc.macro
-         when :has_many : obj.send(self.instantiated_by) << self
-         when :has_one : obj.send("#{self.instantiated_by}=",self) 
+         when :has_many then obj.send(self.instantiated_by) << self
+         when :has_one then obj.send("#{self.instantiated_by}=",self) 
         end
      end
      
@@ -241,7 +241,8 @@ module Skyline::Content
      
      def process_habtm_related_objects(field,values,assoc)
        target_order = values.delete("_order") # This is discarded, a HABTM relationship cannot have a positionfield
-       target_ids = values.map{|k,v| v["_target_id"].to_i }
+       # We have to filter oud the "-" value which we need to make this field come through.
+       target_ids = values.map{|k,v| v["_target_id"] == "-" ? nil : v["_target_id"].to_i }.compact
        current_ids = self.send("#{field.name.to_s.singularize}_ids")
        if target_ids.sort != current_ids.sort
          objects = assoc.klass.find(target_ids).inject({}){|mem,o|mem[o.id] = o; mem}

data/lib/skyline/content/field_meta_data.rb

@@ -287,8 +287,8 @@ module Skyline::Content
     #--
     def field_create_defaults(options)
       case options[:editor]
-        when :textile : {:cache => true} 
-        when :inline_list : {:hidden => [:list,:create]}
+        when :textile then {:cache => true} 
+        when :inline_list then {:hidden => [:list,:create]}
         else {}
       end
     end

data/lib/skyline/content/stack.rb

@@ -101,7 +101,7 @@ class Skyline::Content::Stack < Array
         logger.debug "Trying: #{type} :: #{self.last.class.reflect_on_association(type.to_sym).inspect}"
         assoc = self.last.class.reflect_on_association(type)
         self << case assoc.macro
-          when :has_many : self.last.send(type).build
+          when :has_many then self.last.send(type).build
           else assoc.klass.new
         end
       end

data/lib/skyline/content_item_section_selectable.rb

@@ -13,9 +13,9 @@
 # 
 #    class  Model < ActiveRecord::Base
 #      -- If the model has a 'published' column:
-#      named_scope :for_content_item_section, :conditions => {:published => true}
+#      scope :for_content_item_section, :conditions => {:published => true}
 #      -- else
-#      named_scope :for_content_item_section, {}
+#      scope :for_content_item_section, {}
 #    end
 
 
@@ -24,9 +24,9 @@ module Skyline::ContentItemSectionSelectable
     Skyline::Sections::ContentItemSection.register_selectable_model(base)
     
     if base.column_names.include?("published")
-      base.send :named_scope, :for_content_item_section, :conditions => {:published => true}
+      base.send :scope, :for_content_item_section, :conditions => {:published => true}
     else
-      base.send :named_scope, :for_content_item_section, {}
+      base.send :scope, :for_content_item_section, {}
     end
   end
 end

data/lib/skyline/deprecated/version3_0_8.rb

@@ -9,9 +9,9 @@ module Skyline
       base.send(:include, Skyline::BelongsToReferable)
       
       base.class_eval do
-        named_scope(:published, {}) unless method_defined?(:published)
+        scope(:published, {}) unless method_defined?(:published)
         
-        named_scope(:with_site, {}) unless method_defined?(:with_site)
+        scope(:with_site, {}) unless method_defined?(:with_site)
       end
       
       class << base 

data/lib/skyline/engine.rb

@@ -0,0 +1,37 @@
+require 'skyline'
+require 'rails'
+require 'fileutils'
+require Skyline.root + 'config/initializers/gem_dependencies'
+
+module Skyline
+  class Engine < Rails::Engine
+    config.autoload_paths << (Skyline.root + "lib").to_s
+    
+    # Vendor paths
+    # TODO: Check if we need to do the load_path magic we had before:
+    #   application_vendor_index = $LOAD_PATH.index(Rails.root + "vendor") || 0
+    #   $LOAD_PATH.insert(application_vendor_index + 1, vendor_path)
+    vendor_path = (Skyline.root + "vendor").to_s    
+    config.autoload_paths << vendor_path
+    config.autoload_once_paths << vendor_path
+        
+    initializer "skyline.setup_public_paths" do |app|
+      puts "Setup public paths"
+      public_path = Pathname.new(Rails.public_path) + "skyline"
+      unless public_path.exist? 
+        FileUtils.rm(public_path) if public_path.symlink?
+
+        puts "=> Skyline: Creating assets symlink to '#{public_path}'"
+        FileUtils.ln_s((Skyline.root + "public/skyline").relative_path_from(Pathname.new(Rails.public_path)),public_path)
+      end      
+    end
+    
+    initializer "skyline.setup_plugins_manager" do |app|
+      app.config.skyline_plugins_manager = Skyline::Plugins::Manager.new(app)
+      if app.config.cache_classes || !app.config.reload_plugins
+        app.config.skyline_plugins_manager.load_all!
+      end      
+    end
+    
+  end
+end

data/lib/skyline/form_builder.rb

@@ -41,7 +41,7 @@ class Skyline::FormBuilder < ActionView::Helpers::FormBuilder
   # 
   # @return [String]
   def label(method, text = nil, options = {})
-    if @object.errors[method]
+    if @object.errors[method].present?
       super(method,text,options.merge(:class => "invalid #{options[:class]}".strip))
     else
       super
@@ -61,7 +61,7 @@ class Skyline::FormBuilder < ActionView::Helpers::FormBuilder
   # with help of {Skyline::NestedAttributesPositioning} module)
   # 
   # @example Usage:
-  #   <% article_form.fields_for "sections_attributes", section, :index => 5 do |s| %>
+  #   <%= article_form.fields_for "sections_attributes", section, :index => 5 do |s| %>
   #     <%= s.hidden_field :id unless s.object.new_record? %>
   #     <%= s.hidden_field :_destroy, :class => "delete" %>
   #     <%= s.positioning_field %>
@@ -121,16 +121,16 @@ class Skyline::FormBuilder < ActionView::Helpers::FormBuilder
     options = parms.extract_options!
     method_options = options.except(:text_suffix)
     
-    if @object.errors[method]
+    if @object.errors[method].present?
       method_options[:class] ||= ""
       method_options[:class] << " invalid"
     end
     
-    parms << method_options if method_options.any?    
+    parms << method_options if method_options.present?    
     html = yield(parms)
     html << options[:text_suffix] if options[:text_suffix]
 
-    if @object.errors[method]
+    if @object.errors[method].present?
       html + fieldset_errors(method)
     else
       html
@@ -144,15 +144,15 @@ class Skyline::FormBuilder < ActionView::Helpers::FormBuilder
   # @param attribute [String,Symbol] The attribute to get the errors for
   # @return [String,nil] A string containing each error in a div or nil if there are no errors.
   def fieldset_errors(attribute)
-    return unless @object.errors[attribute]
+    return unless @object.errors[attribute].present?
     out = []
-    if errs = @object.errors[attribute]
+    if (errs = @object.errors[attribute]).present?
       errs = [errs] if self.single_error_message?(errs)
       out = errs.map do |err|        
         @template.content_tag("div",err,:class => "error")
       end
     end
-    out.join("\n")
+    out.join("\n").html_safe
   end
   
   # The ID that a field for a certain field would get.

data/lib/skyline/linkable.rb

@@ -0,0 +1,28 @@
+# If included the object will be linkable 
+# currently only works on Articles
+module Skyline::Linkable
+  
+  class << self
+    def linkables
+      Skyline::Configuration.articles.select{|c| c < Skyline::Linkable }
+    end
+  end
+
+  def self.included(base)
+    raise(TypeError, "Expected #{base.inspect} to be a subclass of Skyline::Article") unless base < Skyline::Article
+    
+    class << base
+      def linkable?; true; end
+    end
+    
+  end
+  
+  # The URL this linkable can be found on. Needed to create the link
+  # 
+  # @return String The URL
+  # @abstract Implement in subclass
+  def url
+    raise "Implement in subclass"
+  end  
+  
+end

data/lib/skyline/plugins/manager.rb

@@ -0,0 +1,77 @@
+# The {Skyline::Plugins::Manager} load all plugins. Currently the manager is quite
+# 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::Plugins::Manager
+  
+  attr_reader :app
+  
+  def initialize(app)
+    @app = app
+    init_all!
+  end
+  
+    
+  # Initialize all plugins
+  def init_all!
+    FileUtils.mkdir(self.public_path) unless self.public_path.exist?
+
+    self.plugins.each{|path, plugin| plugin.init! }
+  end
+
+  # Load all plugins
+  def load_all!
+    self.plugins.each{|path, plugin| plugin.load! }  
+  end
+  
+  # The path where all skyline plugins reside
+  # 
+  # @return [Pathname] Path of the plugins
+  def plugin_path
+    self.app.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(self.app.paths.public.to_a.first) + "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] = Skyline::Plugins::Plugin.new(path, self) 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