westarete-skylinecms 3.0.8.20100329

data/doc/Bundler.md

@@ -0,0 +1,71 @@
+Setting up Bundler for a Rails 2.3 application
+==============================================
+
+Requirements
+------------
+
+* Ruby >= 1.8.6
+* Rubygems >= 1.3.5
+* Rails >= 2.3.4
+* Bundler 0.7.0
+
+Setup bundler to provide all necessary gems
+-------------------------------------------
+
+Create the file `Gemfile` in your RAILS\_ROOT and add the following lines:
+
+    bundle_path "vendor/bundler_gems"
+    gem "rails"
+    disable_system_gems
+    
+### Including extra Gemfiles?
+
+To make sure bundler handles all the required gems including the ones from plugins use
+the following code:
+
+    my_gemfile = File.join(File.dirname(__FILE__), 'vendor', 'plugins', 'my_plugin', 'Gemfile')
+    instance_eval(File.read(my_gemfile), my_gemfile)
+
+Create initializer for Bundler
+------------------------------
+
+Create file called `config/preinitializer.rb` and add the follwoing line:
+
+    require "#{File.dirname(__FILE__)}/../vendor/bundler_gems/environment"
+
+Initialize Bundler before Rails boots
+-------------------------------------
+
+Add the following to `config/boot.rb`, just before the `Rails.boot!` statement.
+
+    # for bundler
+    class Rails::Boot
+      def run
+        load_initializer
+        extend_environment
+        Rails::Initializer.run(:set_load_path)
+      end
+      def extend_environment
+        Rails::Initializer.class_eval do
+          old_load = instance_method(:load_environment)
+          define_method(:load_environment) do
+            Bundler.require_env RAILS_ENV
+            old_load.bind(self).call
+          end
+        end
+      end
+    end
+
+Bundle your gems
+----------------
+
+    gem bundle
+
+Using git?
+----------
+If you're using git we advise you to put the following lines in your .gitignore
+
+    vendor/bundler_gems/doc
+    vendor/bundler_gems/environment.rb
+    vendor/bundler_gems/gems
+    vendor/bundler_gems/specifications

data/doc/INSTALL.md

@@ -0,0 +1,94 @@
+Skyline installation instructions
+=================================
+
+Choose your flavour
+-------------------
+
+**Install as a gem** The skylinecms gem is perfect if you want to have stable environment
+and don't care too much about cutting-edge new features. We release new versions fairly
+often.
+
+**Install the plugin** Use the plugin if you want to be on the latest development version
+with all the 'cool' new features. Especially if you use git, because we're hosting the
+source on github. It's of course entirely possible to use a stable tagged version as a
+plugin too.
+
+Create your rails app
+---------------------
+
+Create an empty rails app. Make sure you're usin MySQL for now,
+we didn't test with other databases yet.
+
+    rails my_app --database=mysql
+    cd my_app
+
+Installation as a gem
+---------------------
+
+Install the gems, and initialize Skyline. 
+
+    gem install skylinecms
+    skylincms init
+    
+Continue below.
+
+Installation as plugin
+-----------------------
+
+Download the Skyline source from [http://github.com/DigitPaint/skyline](http://github.com/DigitPaint/skyline).
+You can use it as a Git submodule or yust download the zip version and unpack it to
+`vendor/plugins/skyline`
+
+If you're using bundler, add the following to your `Gemfile`
+
+    skyline_gemfile = File.join(File.dirname(__FILE__), 'vendor', 'plugins', 'skyline', 'Gemfile')
+    instance_eval(File.read(skyline_gemfile), skyline_gemfile)
+
+Setup your database
+-------------------
+
+Modify `config/database.yml` to match your database configuration and then run:
+
+    rake db:create
+    rake skyline:db:migrate
+    rake skyline:db:seed
+    
+Create your first user and grant him/her access
+-----------------------------------------------
+
+Open a Rails console by running `./script/console`
+
+    u = Skyline::User.new(:email => 'admin@admin.com', :password => 'secret')
+    u.roles << Skyline::Role.first
+    u.save!
+
+Make sure the user exists in the database.
+
+If you went the "gem route" you're done now just start the server with `./script/server`
+and browse to `http://localhost:3000/skyline` and log in with the just created user.
+
+Extra work when using the plugin
+--------------------------------
+
+### Create configuration file
+
+Create a Rails initializer in `config/initializers` (we call it `skyline_configuration.rb`) and
+add the following:
+
+    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
+
+### Create template folder
+
+Create the template folder in your `app` directory.
+
+    mkdir app/templates
+
+### Add default route for pages
+
+Open `config/routes.rb` and add the default Skyline route below all other routes:
+
+    map.connect '*url', :controller => "skyline/site/pages", :action => "show"  

data/doc/MIGRATION.md

@@ -0,0 +1,69 @@
+Skyline Version Migration
+=========================
+
+General update recipe
+---------------------
+
+After every Skyline update make sure that:
+
+* You have updated your `Gemfile`, or the `config.gem` specifications in your `environment.rb`.
+* Run `rake skyline:db:migrate` to update your Skyline tables.
+* Run `rake skyline:db:seed` to update roles/rights and other important data updates.
+* **Plugin users only!** The assets (`RAILS_ROOT/public/skyline`) are from the new version. If they are symlinked, Skyline will 
+  take care of them for you.
+
+Version 3.0.7 -> Version 3.0.8
+------------------------------
+
+There are no pressing changes you need to make to your implementation. Keep in mind however
+that we deprecated some methods. The deprecated methods will be removed in version 3.1.0
+
+**page\_sections\_per_column** in templates. Use `sections_per_column` instead. The old method
+is still available as an alias.
+
+**setting and page\_from\_settings** in templates. These two helpers are deprecated
+in favour of `Settings.get` for `setting` and `Settings.get_page` for `page_from_setting`. The
+method signatures are identical was merly a restructuring.
+
+First OS release -> Version 3.0.7
+---------------------------------
+
+**1. Template changes: render.peek_until** Peek until doesn't skip forward in the collection 
+anymore. The old behaviour was inconsistent with peek. All peek functions now only look forward.
+Replace all occurences of `var = peek_until...` and make sure they manually do `skip!(var.size)`
+a better sollution is to use `render_until`.
+
+**2. Template changes: @Page\_class** `@Page_class` is no longer accesible in the renderer. Use
+`site.root` if you need to access the root class.
+
+**3. Template changes: Renderer partials** You no longer need to pass the currently rendererd object
+to partials. You can access the currently rendered object by using `renderer.object`.
+
+**3. Custom sections: Buttons are no longer images** The helpers `button_image` has been removed
+and the syntax of `submit_button` and `submit_button_to` has changed. Search for occurences of one 
+of these three helpers and replace them accordingly:
+
+**button_image**
+
+    link_to button_image("small/delete.gif", :alt => :delete), ...
+    
+to
+
+    link_to button_text(:delete), ..., :class => "button small red"
+    
+**submit\_button\_to**
+
+    submit_button_to "small/delete.gif", ..., :value => :delete
+    
+to
+
+    submit_button_to :delete, ..., :class => "small red"
+    
+**submit\_button**
+
+    submit_button "small/delete.gif", ..., :value => :delete
+
+to
+
+    submit_button :delete, ..., :class => "small red"
+    

data/lib/skyline/belongs_to_referable.rb

@@ -0,0 +1,166 @@
+# Use this Module in in a class that references a Page/MediaFile/URL as an association.
+# It adds the class method `belongs_to_referable`. With {Skyline::Referable::ClassMethods#belongs_to_referable} you create a
+# `belongs_to` association to an Page/MediaFile/URL through a RefObject.
+# 
+# @see Skyline::BelongsToReferable::ClassMethods#belongs_to_referable
+#
+# @example Usage
+#
+# class Model < ActiveRecord::Base
+#   include Skyline::BelongsToReferable
+#
+#   belongs_to_referable :teaser      # column teaser_id must be available
+# end
+#
+#
+# @example Gives your Model the following interface:
+#
+# class Model < ActiveRecord::Base
+#   after_save :possibly_destroy_previous_referables
+#   after_destroy :possibly_destroy_referables
+#   before_save :set_refering_type_and_id
+#   after_create :set_refering_id
+#
+#   belongs_to :teaser, :class_name => "Skyline::ObjectRef", :foreign_key => "teaser_id", :dependent => :destroy
+#   accepts_nested_attributes_for :teaser, :reject_if => proc {|attributes| attributes['referable_type'].blank?}, :allow_destroy => true
+#   validates_presence_of :teaser   # only if options[:allow_nil] is not set
+#
+#   def teaser_with_passthrough=(obj) # obj can be an ObjectRef or a Teaser, in which case it will be passed through
+#     # ...
+#   end
+#   alias_method_chain :teaser=, :passthrough
+# end
+#
+module Skyline::BelongsToReferable 
+  def self.included(base)
+    base.extend(ClassMethods)
+
+    # Callbacks
+    base.send(:before_save, :set_refering_type_and_id)
+    base.send(:after_create, :set_refering_id)
+    base.send(:after_save, :possibly_destroy_previous_referables)
+    base.send(:after_destroy, :possibly_destroy_referables)
+    
+    base.send(:cattr_accessor, :referable_contents)
+    base.send(:attr_accessor, :previous_referables)
+    base.send(:alias_method_chain, :clone, :referable_content)
+    
+    
+    base.send("referable_contents=", [])
+  end  
+  
+  module ClassMethods   
+
+    # Defines a relationship to a referable.
+    # 
+    # @see Skyline::BelongsToReferable For a usage example.
+    # 
+    # @overload belongs_to_referable(*fields, options = {})
+    #   @param *fields [String,Symbol] The referable(s) to create associations to.
+    # 
+    #   @option options :allow_nil [true, false] (true) Allow this association to be empty?
+    # 
+    # @return [void]
+    def belongs_to_referable(*fields)
+      options = fields.extract_options!.reverse_merge(:allow_nil => true)
+      fields.each do |f|
+        self.referable_contents << f
+                
+        belongs_to f, :class_name => "Skyline::ObjectRef", :foreign_key => "#{f}_id", :dependent => :destroy
+        accepts_nested_attributes_for f, :reject_if => proc {|attributes| attributes['referable_type'].blank?}, :allow_destroy => true
+
+        unless options[:allow_nil]
+          # validating on :linked instead of :linked_id here; see:
+          #   http://railsforum.com/viewtopic.php?id=30300
+          #   https://rails.lighthouseapp.com/projects/8994/tickets/1943
+          #   https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2815-nested-models-build-should-directly-assign-the-parent          
+          validates_presence_of f
+        end
+
+        self.class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{f}_with_passthrough=(obj)
+            if obj.kind_of?(Skyline::ObjectRef)
+              self.#{f}_without_passthrough = obj
+            else
+              self.attributes = {"#{f}_attributes" => {:referable_type => obj.class.name, :referable_id => obj.id}}
+            end
+          end
+          alias_method_chain :#{f}=, :passthrough
+          
+          def #{f}_attributes=(attributes)
+            referable_params = attributes.delete("referable_attributes")
+            self.previous_referables ||= {}
+            self.previous_referables[:#{f}] = self.#{f}.referable.dup if self.#{f}.andand.referable
+            assign_nested_attributes_for_one_to_one_association(:#{f}, attributes)
+  
+            # only create and modify referable if it is a Skyline::ReferableUri
+            if self.#{f} && attributes[:referable_type] == "Skyline::ReferableUri"
+              self.#{f}.referable.reload if self.#{f}.referable
+              self.#{f}.referable ||= attributes[:referable_type].constantize.new
+            
+              if referable_params.kind_of?(Hash)
+                referable_params.each do |k, v|
+                  self.#{f}.send(k.to_s + "=", v) if self.#{f}.respond_to?(k.to_s + "=")
+                end
+              end
+            end
+          end          
+        END
+      end
+    end
+    
+  end
+  
+  # @private
+  def clone_with_referable_content
+    returning clone_without_referable_content do |clone|      
+      if self.referable_contents.any?
+        self.referable_contents.each do |field|
+          if self.send(field).present?
+            clone.send("#{field}_id=", nil)
+            clone.send("#{field}=", self.send(field).clone)
+          end
+        end
+      end
+    end
+  end
+  
+  protected
+
+  def set_refering_type_and_id
+    self.referable_contents.each do |field|
+      if object_ref = self.send(field) 
+        unless object_ref.marked_for_destruction?
+          object_ref.refering_type = self.class.name
+          object_ref.refering_id = self.id unless self.new_record?
+        end
+      end
+    end
+  end
+  
+  def set_refering_id
+    self.referable_contents.each do |field|
+      if object_ref = self.send(field) 
+        object_ref.update_attribute(:refering_id, self.id) if object_ref.refering_id.blank?
+      end
+    end
+  end
+  
+  def possibly_destroy_previous_referables
+    return unless self.previous_referables
+    self.previous_referables.each do |field, previous_referable|
+      if previous_referable != self.send(field).referable
+        previous_referable.destroy if previous_referable.kind_of?(Skyline::ReferableUri)
+      end
+    end
+  end
+  
+  def possibly_destroy_referables
+    self.referable_contents.each do |field|
+      if object_ref = self.send(field) 
+        object_ref.destroy if object_ref.kind_of?(Skyline::ReferableUri)
+      end      
+    end
+  end
+end
+

data/lib/skyline/cli/base.rb

@@ -0,0 +1,23 @@
+require 'thor'
+
+require File.dirname(__FILE__) + '/init'
+require File.dirname(__FILE__) + '/../../skyline'
+require File.dirname(__FILE__) + '/../version'
+
+module Skyline
+  # @private
+  module Cli
+    # @private
+    class Base < Thor
+      include Thor::Actions
+      
+      add_runtime_options!      
+      
+      desc "init", "Setup Skyline in the current directory, this must be a valid Rails 2.3 application."
+      def init
+        invoke Skyline::Cli::Init
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+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/cli/init/templates/tasks/skyline.rake

@@ -0,0 +1,2 @@
+require 'skyline'
+import Skyline.root + "tasks/implementation.rake"

data/lib/skyline/cli/init.rb

@@ -0,0 +1,119 @@
+require 'pathname'
+require 'fileutils'
+
+module Skyline
+  module Cli
+    # @private
+    class Init < Thor::Group
+      include Thor::Actions
+      
+      def self.source_root
+        Skyline.root.expand_path
+      end
+      
+      def verify_rails_dir
+        say "=> Verifying if this is a Rails(like) app"
+        unless (self.target_dir + "lib").exist? &&
+            (self.target_dir + "public").exist? &&
+            (self.target_dir + "config/environment.rb").exist?
+            
+          raise Thor::Error, "This does not seem like a valid Rails app (need lib, public and config/environment.rb)"
+        end
+      end
+      
+      def add_config_gem
+        environment_rb = (self.target_dir + "config/environment.rb")
+        if File.read(environment_rb) =~ /^\s*config.gem\s+[\":']skylinecms[\"']?(.+[\":']version[\"']?\s*=>\s*[\"'](.+)[\"'])?/i
+          say_status "exist", "Already found gem version #{$2}, not doing anything, check gem dependency manually", :blue
+        else
+          say "=> Adding config.gem line to environment.rb"
+          inject_into_file environment_rb, :after => "Rails::Initializer.run do |config|\n" do
+            "  config.gem \"skylinecms\", :version => \"#{Skyline::VERSION::STRING}\"\n"
+          end
+        end
+      end
+      
+      def create_stub_tasks_file
+        tasks_dir = (self.target_dir + "lib/tasks")
+        
+        say "=> Creating lib/tasks directory"
+        empty_directory tasks_dir
+        
+        say "=> Creating lib/tasks/skyline.rake"
+        copy_file self.template_dir + "tasks/skyline.rake", tasks_dir + "skyline.rake"
+      end
+      
+      def copy_assets
+        say "=> Copying assets"
+        
+        public_dir = (self.target_dir + "public/skyline")
+        if public_dir.exist? || File.symlink?(public_dir)
+          if shell.file_collision("public/skyline")
+            FileUtils.rm_rf(public_dir)
+          else
+            return
+          end
+        end
+        
+        directory "public/skyline/images", public_dir + "images", :recursive => true
+        directory "public/skyline/stylesheets", public_dir + "stylesheets", :recursive => true        
+        directory "public/skyline/javascripts", public_dir + "javascripts", :recursive => true                
+      end
+      
+      def create_skyline_config
+        say "=> Creating config/initializers/skyline_configuration.rb"
+        copy_file self.template_dir + "config/initializers/skyline_configuration.rb", self.target_dir + "config/initializers/skyline_configuration.rb"
+      end
+      
+      def create_development_upload_paths
+        say "=> Creating development upload paths"
+        empty_directory self.target_dir + "tmp"
+        empty_directory self.target_dir + "tmp/upload"        
+        empty_directory self.target_dir + "tmp/cache/media_files/cache"
+        empty_directory self.target_dir + "tmp/cache/rss_sections/cache"        
+      end
+      
+      def create_template_path
+        say "=> Creating skyline template path"
+        empty_directory self.target_dir + "app/templates"
+      end
+      
+      def add_default_pages_route
+        routes_rb = self.target_dir + "config/routes.rb"
+        route_string = "map.connect '*url', :controller => \"skyline/site/pages\", :action => \"show\""
+        
+        say "=> Add default pages route"
+        if File.read(routes_rb) =~ /#{Regexp.escape(route_string)}$/
+          say_status "exist", "default pages route", :blue
+        else
+          inject_into_file routes_rb, :after => "map.connect ':controller/:action/:id.:format'\n" do
+            "\n" +
+            "  # The default Skyline pages route\n" +
+            "  #{route_string}\n"
+          end
+        end
+      end
+      
+      def remove_default_rails_assets
+        say "=> Removing default rails assets"
+        %w{public/index.html public/images/rails.png}.each do |f|
+          if (self.target_dir + f).exist?
+            say_status "removing", f
+            FileUtils.rm(self.target_dir + f)
+          end
+        end
+      end
+      
+      protected
+      
+      def target_dir
+        @_target_dir ||= Pathname.new(Dir.pwd)
+      end
+      
+      def template_dir
+        @_template_dir ||= self.class.source_root + "lib/skyline/cli/init/templates/"
+      end
+      
+    end
+  end
+end

data/lib/skyline/configuration.rb

@@ -0,0 +1,101 @@
+# Contains the default skyline configuration. Currently this is also
+# the place to look for available configuration options.
+#
+# @todo This configuration class will soon change as it's not flexible enough
+#   for out purposes.
+class Skyline::Configuration < Configure
+  
+  defaults do |config|
+    config.name = File.expand_path(Rails.root).split("/").last
+    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"]
+                      }
+    
+    config.articles = []
+    config.content_classes = []
+    
+    config.rss_section_cache_timeout = 1.hour  
+    
+    config.custom_logo = false
+    config.skyline_logo = "/skyline/images/logo.png"
+    config.branding_name = ""
+    
+    # ie: [{:path => "/stylesheets/skyline.css", :if => "lte IE 7"}]
+    config.custom_stylesheets = []
+    
+    if Rails.env == "production"
+      config.assets_path = nil
+      config.media_file_cache_path = nil
+      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")
+    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
+    
+    # enable/disable 'modules'
+    config.enable_multiple_variants = true
+    config.enable_locking = true
+    config.enable_enforce_only_one_user_editing = true
+    config.enable_publication_history = true
+  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")
+    
+    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"]
+    
+    Skyline::Rendering::Renderer.register_renderables(:sections,self["sections"])
+    Skyline::Rendering::Renderer.register_renderables(:articles,self["articles"] + ["Skyline::Page"])      
+  end  
+  
+  def articles
+    self["articles"].map(&:constantize)
+  end  
+  
+  def content_classes
+    self["content_classes"].map(&:constantize)
+  end
+  
+  protected
+    
+  # 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.
+  def check_or_create_path(path, key="assets_path")
+    raise "#{key} must be set!" if path.blank?
+    unless File.directory?(path)
+      if Rails.env == "production"
+        raise("#{key} \"#{path}\" does not exist") 
+      else
+        require 'fileutils'
+        Rails.logger.warn "Creating #{key} directory in \"#{path}\""
+        FileUtils.mkdir_p(path)
+      end
+    end
+  end
+end