westarete-skylinecms 3.0.8.20100329

data/public/skyline/stylesheets/ie.css

@@ -0,0 +1,47 @@
+#mainnavigation,
+#mainnavigation ul,
+#mainnavigation li,
+#mainnavigation li a,
+#mainnavigation li span,
+ul.files,
+ul.files li,
+ul.files li div.file,
+.sections li,
+ul.toptabs,
+.tabs .chrome,
+.innerpanel .submit,
+.innerpanel .actions,
+.tree,
+.tree ul,
+.tree ul li,
+.menubutton li,
+.menubutton li a,
+.selectlist li,
+.selectlist li a{
+  zoom: 1;
+}
+
+input.full{
+  width: 99%;
+}
+
+.section .head,
+.section .body,
+#mceToolbarContainer,
+.content,
+.scrollable{
+  zoom: 1;
+}
+
+#newDir{
+  width: 84px;
+}
+
+.scrollable{
+  background: #fff;
+}
+
+/* Turn off hasLayout */
+.footerPanel .content{
+  zoom: 0;  
+}

data/public/skyline/stylesheets/undohtml.css

@@ -0,0 +1,53 @@
+/* undohtml.css */
+/* (CC) 2004 Tantek Celik. Some Rights Reserved.             */
+/*   http://creativecommons.org/licenses/by/2.0                   */
+/* This style sheet is licensed under a Creative Commons License. */
+
+/* Purpose: undo some of the default styling of common (X)HTML browsers */
+
+/* no list-markers by default, since lists are used more often for semantics */
+ul,ol { list-style:none }
+
+/* avoid browser default inconsistent heading font-sizes */
+/* and pre/code too */
+h1,h2,h3,h4,h5,h6,pre,code { font-size:1em; }
+
+/* remove the inconsistent (among browsers) default ul,ol padding or margin  */
+/* the default spacing on headings does not match nor align with 
+   normal interline spacing at all, so let's get rid of it. */
+/* zero out the spacing around pre, form, body, html, p, blockquote as well */
+/* form elements are oddly inconsistent, and not quite CSS emulatable. */
+/*  nonetheless strip their margin and padding as well */
+ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,body,html,p,blockquote,fieldset,input,td,th,dl,dt,dd
+{ margin:0; padding:0 }
+
+/* whoever thought blue linked image borders were a good idea? */
+a img,:link img,:visited img { border:none }
+
+/* more varnish stripping as necessary... */
+
+/* ============================= */
+/* = Remove all button margins = */
+/* ============================= */
+a.button,
+button { 
+	position: relative;
+	border: 0 none; 
+	padding: 0;
+	cursor: pointer;
+	overflow: visible; /* removes extra side padding in IE */
+}
+
+a.button::-moz-focus-inner,
+button::-moz-focus-inner {
+  border: none;  /* overrides extra padding in Firefox */
+  margin: 0;
+  padding: 0;
+}
+
+a.button span,
+button span { 
+	position: relative;
+	display: block; 
+	white-space: nowrap;	
+}

data/public/skyline/stylesheets/wysiwyg.css

@@ -0,0 +1,28 @@
+body, td, pre {color:#000; font-family:Verdana, Arial, Helvetica, sans-serif; font-size:10px; margin:8px;}
+body {background:#fffffe;}
+/*body.active {background: #fff;}*/
+/*body.mceForceColors {background:#0FF; color:#000;}*/
+h1 {font-size: 2em}
+h2 {font-size: 1.5em}
+h3 {font-size: 1.17em}
+h4 {font-size: 1em}
+h5 {font-size: .83em}
+h6 {font-size: .75em}
+.mceItemTable, .mceItemTable td, .mceItemTable th, .mceItemTable caption, .mceItemVisualAid {border: 1px dashed #BBB;}
+a.mceItemAnchor {width:12px; line-height:6px; overflow:hidden; padding-left:12px; background:url(img/items.gif) no-repeat bottom left;}
+img.mceItemAnchor {width:12px; height:12px; background:url(img/items.gif) no-repeat;}
+img {border:0;}
+table {cursor:default}
+table td, table th {cursor:text}
+ins {border-bottom:1px solid green; text-decoration: none; color:green}
+del {color:red; text-decoration:line-through}
+cite {border-bottom:1px dashed blue}
+acronym {border-bottom:1px dotted #CCC; cursor:help}
+abbr, html\:abbr {border-bottom:1px dashed #CCC; cursor:help}
+
+/* Skyline specific stuff */
+img.right{ float: right; }
+img.left{ float: left; }
+img.block{ display: block; }
+
+table td, table th{ vertical-align: top; }

data/rails/init.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+# Add these directories to the loadpath
+%w{ observers middleware }.each do |dir|
+ ActiveSupport::Dependencies.load_paths << (Skyline.root + "app" + dir).to_s
+end
+
+# Vendor paths
+vendor_path = (Skyline.root + "vendor").to_s
+application_vendor_index = $LOAD_PATH.index(Rails.root + "vendor") || 0
+$LOAD_PATH.insert(application_vendor_index + 1, vendor_path)
+ActiveSupport::Dependencies.load_paths << vendor_path
+ActiveSupport::Dependencies.load_once_paths << vendor_path
+
+# 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
+
+# Load our own plugin initializers
+Dir[Skyline.root + "config/initializers/*.rb"].sort.each do |file|
+ require file
+end
+
+Skyline::PluginsManager.init_all!
+if Rails.configuration.cache_classes || !Rails.configuration.reload_plugins
+  Skyline::PluginsManager.load_all!
+end

data/recipes/deploy.rb

@@ -0,0 +1,31 @@
+namespace :skyline do
+  desc <<-DESC
+    Run the skyline:db:migrate rake task. By default, it runs this in most recently \
+    deployed version of the app. However, you can specify a different release \
+    via the migrate_target variable, which must be one of :latest (for the \
+    default behavior), or :current (for the release indicated by the \
+    `current' symlink). Strings will work for those values instead of symbols, \
+    too. You can also specify additional environment variables to pass to rake \
+    via the migrate_env variable. Finally, you can specify the full path to the \
+    rake executable by setting the rake variable. The defaults are:
+
+      set :rake,           "rake"
+      set :rails_env,      "production"
+      set :migrate_env,    ""
+      set :migrate_target, :latest
+  DESC
+  task :migrate, :roles => :db, :only => { :primary => true } do
+    rake = fetch(:rake, "rake")
+    rails_env = fetch(:rails_env, "production")
+    migrate_env = fetch(:migrate_env, "")
+    migrate_target = fetch(:migrate_target, :latest)
+
+    directory = case migrate_target.to_sym
+      when :current then current_path
+      when :latest  then current_release
+      else raise ArgumentError, "unknown migration target #{migrate_target.inspect}"
+      end
+
+    run "cd #{directory}; #{rake} RAILS_ENV=#{rails_env} #{migrate_env} skyline:db:migrate"
+  end
+end

data/tasks/database.rake

@@ -0,0 +1,66 @@
+namespace :skyline do
+  
+  namespace :db do
+    
+    desc "Migrate the skyline migrations" 
+    task :migrate => :environment 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)
+      end      
+      
+      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby      
+    end
+
+    desc 'Rolls the schema back to the previous version. Specify the number of steps with STEP=n'
+    task :rollback => :environment do
+      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+      ActiveRecord::Migrator.rollback(Skyline.root + 'db/migrate/', step)
+      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+
+    namespace :migrate do
+      desc  'Rollbacks the database one migration and re migrate up. If you want to rollback more than one step, define STEP=x. Target specific version with VERSION=x.'
+      task :redo => :environment do
+        if ENV["VERSION"]
+          Rake::Task["skyline:db:migrate:down"].invoke
+          Rake::Task["skyline:db:migrate:up"].invoke
+        else
+          Rake::Task["skyline:db:rollback"].invoke
+          Rake::Task["skyline:db:migrate"].invoke
+        end
+      end
+  
+      desc 'Resets your database using your migrations for the current environment'
+      task :reset => ["db:drop", "db:create", "db:migrate"]
+  
+      desc 'Runs the "up" for a given migration VERSION.'
+      task :up => :environment do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        raise "VERSION is required" unless version
+        ActiveRecord::Migrator.run(:up, Skyline.root + "db/migrate/", version)
+        Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      end
+  
+      desc 'Runs the "down" for a given migration VERSION.'
+      task :down => :environment do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        raise "VERSION is required" unless version
+        ActiveRecord::Migrator.run(:down, Skyline.root + "db/migrate/", version)
+        Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      end
+    end
+
+    
+    desc "Run all seed files in Skyline.root/db/fixtures/**"
+    task :seed => :environment do
+      Dir[Skyline.root + "db/fixtures/*.rb"].each do |f|
+        load f
+      end
+    end
+    
+  end
+  
+end

data/tasks/implementation.rake

@@ -0,0 +1,2 @@
+# Only import tasks that we want available from the Gem.
+import File.dirname(__FILE__) + "/database.rake"

data/vendor/andand/andand.rb

@@ -0,0 +1,96 @@
+# Taken from http://andand.rubyforge.org/
+
+module AndAnd
+
+  # This module is included in Object, so each of these methods are added
+  # to Object when you require 'andand'. Each method is an *adverb*: they are
+  # intended to be enchained with another method, such as receiver.adverb.method
+  #
+  # The purpose of an adverb is to modify what the primary method returns.
+  #
+  # Adverbs also take blocks or procs, passing the receiver as an argument to the
+  # block or proc. They retain the same semantics with a block or proc as they
+  # do with a method. This behaviour weakly resembles a monad.
+  module ObjectGoodies
+
+    # Returns nil if its receiver is nil, regardless of whether nil actually handles the
+    # actual method ot what it might return.
+    #
+    #    'foo'.andand.size => 3
+    #    nil.andand.size => nil
+    #    'foo'.andand { |s| s << 'bar' } => 'foobar'
+    #    nil.andand { |s| s << 'bar' } => nil
+    def andand (p = nil)
+      if self
+        if block_given?
+          yield(self)
+        elsif p
+          p.to_proc.call(self)
+        else
+          self
+        end
+      else
+        if block_given? or p
+          self
+        else
+          MockReturningMe.new(self)
+        end
+      end
+    end
+  end
+  
+end
+
+class Object
+  include AndAnd::ObjectGoodies
+end
+
+unless Module.constants.include?('BlankSlate')
+  if Module.constants.include?('BasicObject')
+    module AndAnd
+      class BlankSlate < BasicObject
+      end
+    end
+  else
+    module AndAnd
+      class BlankSlate
+        def self.wipe
+          instance_methods.reject { |m| m =~ /^__/ }.each { |m| undef_method m }
+        end
+        def initialize
+          BlankSlate.wipe
+        end
+      end
+    end
+  end
+end
+
+module AndAnd
+
+  # A proxy that returns its target without invoking the method you
+  # invoke. Useful for nil.andand and #dont
+  class MockReturningMe < BlankSlate
+    def initialize(me)
+      super()
+      @me = me
+    end
+    def method_missing(*args)
+      @me
+    end
+  end
+
+  # A proxy that returns its target after invoking the method you
+  # invoke. Useful for #me
+  class ProxyReturningMe < BlankSlate
+    def initialize(me)
+      super()
+      @me = me
+    end
+    def method_missing(sym, *args, &block)
+      @me.__send__(sym, *args, &block)
+      @me
+    end
+  end
+
+end
+

data/vendor/digitpaint/configure.rb

@@ -0,0 +1,144 @@
+# class NewsletterEditor < Configure
+#   
+# end
+#
+# NewsletterEditor.configure do |c|
+#   c.upload_path = "bla"
+#   c.fli = "fla"
+# end
+#
+require 'singleton'
+class Configure
+  include Singleton
+
+  class ConfigurationStorage < Hash
+    def method_missing(meth,*params)
+      meth = meth.to_s
+      if meth =~ /=$/
+        self[meth.sub(/=$/,"")] = params.first
+      elsif self.has_key?(meth)
+        self[meth]
+      else 
+        super(meth,*params)
+      end
+    end  
+  end  
+  
+  class << self
+    def configure(*params,&block)
+      self.instance.configure(*params,&block)
+    end
+    
+    def defaults(*params, &block)
+      if block_given?
+        yield self.instance.instance_variable_get(:@_defaults)
+      else
+        self.instance.instance_variable_get(:@_defaults)
+      end
+    end
+    
+    def configuration
+      self.instance.configuration
+    end
+    
+    def method_missing(meth,*params)
+      if self.instance.has_key?(meth.to_s)
+        self.instance.send(meth, *params)
+      else
+        super(meth,*params)
+      end
+    end
+  end
+    
+  def initialize
+    @_configuration = {}
+    @_defaults = ConfigurationStorage.new
+  end
+  
+  def configure(*params)
+    if block_given?
+      self.before_configure      
+      yield self
+      self.after_configure
+    else
+      self
+    end
+  end
+  
+  
+  # Called before a configureblock is given
+  def before_configure
+  end
+  
+  # Called after the configure block
+  def after_configure
+  end
+  
+  def method_missing(meth,*params)
+    meth = meth.to_s
+    if meth =~ /=$/
+      self[meth.sub(/=$/,"")] = params.first
+    elsif has_key?(meth)
+      self[meth]
+    else 
+      super(meth,*params)
+    end
+  end
+  
+  def [](key)
+    if @_configuration.has_key?(key) 
+      @_configuration[key] 
+    elsif @_defaults.has_key?(key)
+      @_defaults[key]
+    end
+  end
+  
+  def []=(key,value)    
+    @_configuration[key] = value
+  end
+  
+  def has_key?(key)
+    @_configuration.has_key?(key) || @_defaults.has_key?(key)
+  end
+  
+  def configuration
+    @_defaults.merge(@_configuration)
+  end
+  
+end
+
+# Some basic tests (Don't laugh!)
+if __FILE__ == $0
+  class T1 < Configure
+    defaults do |c|
+      c.name = "Test1"
+    end
+    defaults.id = 1
+  end
+  
+  class T2 < Configure
+    defaults do |c|
+      c.name = "Test2"
+      c.test = true
+      c.thingy = nil
+    end
+    defaults.id = 2
+    
+    def thingy=(value)
+      puts "HELP!" if value.nil?
+      self[:thingy] = value
+    end
+  end
+  
+  T2.configure.name = "Test - 2"
+  T2.configure do |conf|
+    conf.bla = "blaa"
+    conf.thingy = nil
+  end
+  
+  puts T1.configuration.inspect
+  puts T2.configuration.inspect
+  
+  puts T1.name  
+  
+end

data/vendor/digitpaint/nested_attributes_positioning.rb

@@ -0,0 +1,70 @@
+# Module to help with on the fly reordered elements in a form
+# accepts_nested_attributes_for is a great helper, but can't handle reordering of the elements (and saving the new position)
+# 
+# So, here comes the solution. It includes two parts: a helper method in the FormBuilderWithErros and this Module
+#
+# Example view:
+#
+#   <% article_form.fields_for "sections_attributes", section, :index => guid do |s| %>
+#     <%= s.hidden_field :id unless s.object.new_record? %>
+#     <%= s.hidden_field :_destroy, :class => "delete" %>
+#     <%= s.positioning_field %>
+#     ...
+#   <% end %>
+#
+# This will result in param attributes like {"article" => {"sections_attributes" => {"674" => ..., "425" => ..., "256" => ...}, 
+#                                                          "sections_position" => ["256", "674", "425"]}}
+# NB: 674, 425 and 256 are the indexes (or guids)
+# The key "sections_position" is added with the help of positioning_field and states the wanted order of the sections (the order 
+# is the order in which the elements of the form were when the form was posted - so they could've been moved around by the user).
+#
+# 
+# Without use of this module this will result in an error: "unknown attribute: sections_position", so we include the module in our 
+# Article(!) Class (well actually in Skyline it should be in the Variant class, but I use article_form here to keep the example 
+# short)
+# This module triggers on associations that have been configured with accepts_nested_attributes_for.
+#
+# class Skyline::Article < Skyline::ArticleVersion
+#   include NestedAttributesPositioning
+#   accepts_nested_attributes_for :sections
+#   ....
+# end
+
+
+module NestedAttributesPositioning
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send :cattr_accessor, :accepts_nested_attributes_for_associations
+    base.send :accepts_nested_attributes_for_associations=, []
+    base.send :alias_method_chain, :attributes=, :positioning
+  end
+      
+  module ClassMethods
+    def accepts_nested_attributes_for(*attr_names)
+      super
+      attr_names.extract_options!
+      self.accepts_nested_attributes_for_associations += attr_names
+    end
+  end
+  
+  def attributes_with_positioning=(attributes)
+    a = attributes.dup
+    self.accepts_nested_attributes_for_associations.map{|association| handle_positioning_for_association(association, a)}
+    self.attributes_without_positioning = a
+  end
+  
+  def handle_positioning_for_association(association, attributes)
+    positions = attributes.delete("#{association}_position")
+    if positions.andand.kind_of?(Array)
+      attributes_hash = attributes.delete("#{association}_attributes")
+      sorted_attributes = []
+      positions.each_with_index do |index, position|
+        attributes_hash[index][:position] = position
+        sorted_attributes << attributes_hash[index]
+      end
+    
+      self.attributes_without_positioning = {"#{association}_attributes" => sorted_attributes}
+      self.send(association).sort!{|a,b| a.position <=> b.position}
+    end
+  end
+end

data/vendor/digitpaint/personify/README.md

@@ -0,0 +1,86 @@
+Personify : personalisation template language
+=============================================
+
+Personfify is meant for use in environments where templates just need
+to be personalized.
+
+Basic syntax
+------------
+
+Alle expressions are wrapped in brackets ([ ]). All code outside
+of brackets will not be evaluated.
+
+If the return statement of an expression is nil, it won't be replaced
+by it's output.
+
+All whitespace within expressions is ignored.
+
+Simple substitution
+-------------------
+
+The simplest use of the personify template language is to just use
+the standard substitution expressions. A substitution expression
+exists of a key which will be replaced if it's found in the context.
+
+With context:
+
+    {"key" => "value"}
+
+Examples:
+
+    [KEY] => value
+    [UNKNOWN] => [UNKNOWN]
+    
+Substitutions with fallback
+--------------------------- 
+
+A more advanced feature is to use fallbacks on missing keys. If a key can't
+be found in the context, all alternative keys (separated by a pipe (|))
+will be tried until a non-nil value is found. If a the last alternative
+returns nil, the original expression won't be replaced.
+
+You can also specify strings as fallbacks, they will always return the string.
+See also the note on strings below.
+
+With context:
+
+    {"key" => "value"}
+
+Examples:
+    
+    [UNKNOWN | KEY] => value
+    [UNKNOWN1 | UNKNOWN2 | "default"] => default
+    [UNKNOWN1 | UNKNOWN2 | default] => default
+
+Function calls
+--------------
+
+For more flexibility, it is possible to put functions in
+the context by means of lamda's and procs. However you need to be very
+carefull with accepting parameters as Personify will just splat all
+parameters into the proc's call method. If an expected function
+doesn't respond to a call method, it just works like a normal substitution.
+
+With context:
+
+    {
+      "key1" => "v1", 
+      "key2" => "v2" 
+      "ampersandize" => Proc.new{|*c| c.join(" & ") }
+    }
+
+Examples:
+    
+    [AMPERSANDIZE(KEY1,KEY2)] => v1 & v2
+    [AMPERSANDIZE(KEY1 , "default")] => v1 & default
+    [AMPERSANDIZE("1","2","3")] => 1 & 2 & 3
+    [AMPERSANDIZE("1",2,3)] => 1 & 2 & 3    
+
+Strings
+-------
+
+Strings can be used either as parameters for a function or in an expression
+as an alternative. Strings don't necessarily need to be quoted as long
+as they don't contain any of these characters: "]),|
+
+Strings cannot ever contain double qoutes (").