caboose-cms 0.2.95 → 0.2.96

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTk4NzgwZDZiMDIyOGM5ZDhlMDY3YmMwYTE1MjIxZGQ0ZDA3ODA0NA==
+    YzlhMjFjOGFmMmMxMjU5MTRjZDA0MWQ3ODAxZDQ4NDdmZjVhOWIxOA==
   data.tar.gz: !binary |-
-    ODcwMTk0ZWZkOWUyNDRmOTM2YzRlYmY2MDYxMjA0YzE3ZDAxNzdhZA==
+    OGQ4ZThiOTM1NDkyOGQxMzFmYzM5ODk5M2ZhZjMyNzJmMjU5MTA4Nw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NWJkMGQ0ZjkyMTljM2NjZTA2M2MxYTgwYjRhNjZkYmNjMTk0MjEwOGY5Mzc1
-    ZGVhMzQ3NjRlNDhkZTQwMWMwMTI4ZmU4ZmFkZDE3OTg3MjQ4MjAyOTdmNjVi
-    NGEzMTQzNWY1MWNkY2U2NGFkYjM2ZGEyMjNkMTVjYzNiOGQ3Yjk=
+    YmZjOTcwMzY4MGI5NDRkODMzODlkZTgxMzE4OGQ3Mzg1ZmVjNDEzMWYyNmQ0
+    ZmI3NzQ0ZDAwMTVhOGI2ZTMwMTA2ZGZiYjQ0ZmYwNjEzNzBjNDRjNDQ2Yjk1
+    Y2U1MzIwZDUzMGQ3MzMzOGVkYjZlZGJlNDVhNjAyNTI2NWU2ODU=
   data.tar.gz: !binary |-
-    NGQ1NDkxYzE4NTIzMDM1ZWMwYzU2YzFkZTZlMTc0NTJmYTU3NmI5NzE0YzNh
-    M2U3YTZiM2YwNzcwNTkyZTM4YzI2MmZlN2U3M2NiZDY3ZTNkODIxNzVjY2Iy
-    MjdkY2VkZDU3N2I5YjA5YTNmODI3OTcxMmUwNTA1YTRmMjQ3MDU=
+    YjQ5MDc4MTczM2Y5MGVjYmEwMmYyMTg1MDZiYzU2MmI1Nzk0MzVkYTc2YTg1
+    ZjkyOTY4YTVhMzAwMTI5OTc4MTgxMjA4Y2QyOWVkY2FjMzY3NDMwMTUzNDJm
+    Mzk2ZWQwY2ExY2M1MTMxNTlmZDY1MDQ0MTViYThmYjYxNzRkNTU=

data/app/models/caboose/database_session.rb

@@ -0,0 +1,5 @@
+
+class Caboose::DatabaseSession < ActiveRecord::Base
+  self.table_name = "sessions"
+  attr_accessible :session_id, :data, :created_at, :updated_at	
+end

data/app/models/caboose/schema.rb

@@ -0,0 +1,188 @@
+
+class Caboose::Schema < Caboose::Utilities::Schema
+    
+  # Tables (in order) that were renamed in the development of the gem.
+  def self.renamed_tables
+    {
+      :roles_users       => :role_memberships,
+      :permissions_roles => :role_permissions
+    }
+  end
+  
+  # Any column indexes that need to exist in the database
+  def self.indexes
+    {    
+      :role_memberships          => [ :role_id    , :user_id          ],
+      :role_permissions          => [ :role_id    , :permission_id    ],
+      :post_category_memberships => [ :post_id    , :post_category_id ],
+      :sessions                  => [ :session_id , :updated_at       ]
+    }
+  end      
+  
+  # The schema of the database
+  # { Model => [[name, data_type, options]] }
+  def self.schema      
+    {
+      Caboose::User => [  	
+        [ :first_name           , :string     ],     
+        [ :last_name            , :string     ], 
+        [ :username             , :string     ], 
+        [ :email                , :string     ], 
+        [ :phone                , :string     ], 
+        [ :password             , :string     ], 
+        [ :password_reset_id    , :string     ], 
+        [ :password_reset_sent  , :datetime   ], 
+        [ :token                , :string     ], 
+        [ :date_created         , :datetime   ]
+      ],
+      Caboose::Role => [    
+        [ :parent_id            , :integer  ], 
+        [ :name                 , :string   ],
+        [ :description          , :string   ]
+      ],
+      Caboose::Permission => [    
+        [ :resource , :string ], 
+        [ :action   , :string ]
+      ],
+      Caboose::RoleMembership => [    
+        [ :role_id, :integer ],
+        [ :user_id, :integer ]
+      ],
+      Caboose::RolePermission => [
+	    	[ :role_id        , :integer ],
+	    	[ :permission_id  , :integer ]		
+	    ],
+	    Caboose::Asset => [
+        [ :page_id        , :integer    ],  
+        [ :user_id        , :integer    ], 
+        [ :date_uploaded  , :datetime   ], 
+        [ :name           , :string     ], 
+        [ :filename       , :string     ], 
+        [ :description    , :string     ], 
+        [ :extension      , :string     ]
+      ],
+      Caboose::Page => [        
+        [ :parent_id             , :integer ], 
+        [ :title                 , :string  ],
+        [ :menu_title            , :string  ],
+        [ :content               , :text    ],
+        [ :slug                  , :string  ],
+        [ :alias                 , :string  ],
+        [ :uri                   , :string  ],
+        [ :redirect_url          , :string  ],
+        [ :hide                  , :boolean , :default => false ],
+        [ :content_format        , :integer , :default => Caboose::Page::CONTENT_FORMAT_HTML ],
+        [ :custom_css            , :text    ],
+        [ :custom_js             , :text    ],
+        [ :linked_resources      , :text    ],
+        [ :layout                , :string  ],
+        [ :sort_order            , :integer , :default => 0                ],
+        [ :custom_sort_children  , :boolean , :default => false            ],
+        [ :seo_title             , :string  , :limit => 70                 ],
+        [ :meta_description      , :string  , :limit => 156                ],
+        [ :meta_robots           , :string  , :default => 'index, follow'  ],
+        [ :canonical_url         , :string  ],
+        [ :fb_description        , :string  , :limit => 156 ],
+        [ :gp_description        , :string  , :limit => 156 ]
+      ],
+      Caboose::Post => [  
+        [ :title       , :text     ],  		 	 
+        [ :body        , :text 		 ],  	 
+        [ :hide        , :boolean  ], 	 
+        [ :image_url   , :text 		 ],
+        [ :created_at  , :datetime ],
+        [ :updated_at  , :datetime ]
+      ],
+      Caboose::PostCategory => [
+        [ :name , :string ]
+      ],    
+      Caboose::PostCategoryMembership => [    
+        [ :post_id          , :integer ],
+        [ :post_category_id , :integer ]
+      ],    
+      Caboose::PagePermission => [
+        [ :role_id , :integer  ],  
+        [ :page_id , :integer  ],
+        [ :action  , :string   ]
+      ],
+      Caboose::DatabaseSession => [
+        [ :session_id  , :string   , :null => false ],
+        [ :data        , :text                      ],
+        [ :created_at  , :datetime , :null => true  ],
+        [ :updated_at  , :datetime , :null => true  ]
+      ],    
+      Caboose::Setting => [    
+        [ :name  , :string ],
+        [ :value , :text   ]
+      ]
+    }
+
+  end
+  
+  # Loads initial data into the database
+  def self.load_data    
+    
+    admin_user = nil
+    if !Caboose::User.exists?(:username => 'admin')
+      admin_user = Caboose::User.create(:first_name => 'Admin', :last_name => 'User', :username => 'admin', :email => 'william@nine.is')
+      admin_user.password = Digest::SHA1.hexdigest(Caboose::salt + 'caboose')
+      admin_user.save
+    end
+    admin_user = Caboose::User.where(:username => 'admin').first if admin_user.nil?
+    
+    Caboose::Role.create(:parent_id => -1           , :name => 'Admin'               ) if !Caboose::Role.exists?(:name =>  'Admin'               )
+    admin_role  = Caboose::Role.where(:name => 'Admin'               ).first
+    Caboose::Role.create(:parent_id => -1           , :name => 'Everyone Logged Out' ) if !Caboose::Role.exists?(:name =>  'Everyone Logged Out' )
+    elo_role    = Caboose::Role.where(:name => 'Everyone Logged Out' ).first
+    Caboose::Role.create(:parent_id => elo_role.id  , :name => 'Everyone Logged In'  ) if !Caboose::Role.exists?(:name =>  'Everyone Logged In'  )
+    eli_role    = Caboose::Role.where(:name => 'Everyone Logged In'  ).first
+    
+    Caboose::User.create(:first_name => 'John', :last_name => 'Doe', :username => 'elo', :email => 'william@nine.is') if !Caboose::User.exists?(:username => 'elo')
+    elo_user = Caboose::User.where(:username => 'elo').first
+     
+    Caboose::Permission.create(:resource => 'all'         , :action => 'all'    ) if !Caboose::Permission.exists?(:resource => 'all'	       , :action => 'all'    )
+    Caboose::Permission.create(:resource => 'users'	      , :action => 'view'   ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'view'   )
+    Caboose::Permission.create(:resource => 'users'	      , :action => 'edit'   ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'edit'   )
+    Caboose::Permission.create(:resource => 'users'	      , :action => 'delete' ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'delete' )
+    Caboose::Permission.create(:resource => 'users'	      , :action => 'add'    ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'add'    )
+    Caboose::Permission.create(:resource => 'roles'	      , :action => 'view'   ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'view'   )
+    Caboose::Permission.create(:resource => 'roles'	      , :action => 'edit'   ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'edit'   )
+    Caboose::Permission.create(:resource => 'roles'	      , :action => 'delete' ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'delete' )
+    Caboose::Permission.create(:resource => 'roles'	      , :action => 'add'    ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'add'    )
+    Caboose::Permission.create(:resource => 'permissions' , :action => 'view'   ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'view'   )
+    Caboose::Permission.create(:resource => 'permissions' , :action => 'edit'   ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'edit'   )
+    Caboose::Permission.create(:resource => 'permissions' , :action => 'delete' ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'delete' )
+    Caboose::Permission.create(:resource => 'permissions' , :action => 'add'    ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'add'    )
+  
+    # Add the admin user to the admin role
+    Caboose::RoleMembership.create(:user_id => admin_user.id, :role_id => admin_role.id) if !Caboose::RoleMembership.exists?(:user_id => admin_user.id, :role_id => admin_role.id)
+    
+    # Add the elo to the elo role
+    Caboose::RoleMembership.create(:user_id => elo_user.id, :role_id => elo_role.id) if !Caboose::RoleMembership.exists?(:user_id => elo_user.id, :role_id => elo_role.id)
+  
+    # Add the all/all permission to the admin role
+    admin_perm = Caboose::Permission.where(:resource => 'all', :action => 'all').first
+    Caboose::RolePermission.create(:role_id => admin_role.id, :permission_id => admin_perm.id) if !Caboose::RolePermission.exists?(:role_id => admin_role.id, :permission_id => admin_perm.id)
+    
+    # Create the necessary pages
+    Caboose::Page.create(:title => 'Home'  , :parent_id => -1, :hide => 0, :layout => 'home', :uri => '') if !Caboose::Page.exists?(:title => 'Home')
+    home_page = Caboose::Page.where(:title => 'Home', :parent_id => -1).first
+    Caboose::Page.create(:title => 'Admin' , :parent_id => home_page.id, :hide => 0, :layout => 'admin', :alias => 'admin', :slug => 'admin', :uri => 'admin') if !Caboose::Page.exists?(:alias => 'admin')
+    admin_page = Caboose::Page.where(:alias => 'admin').first
+    Caboose::Page.create(:title => 'Login' , :parent_id => home_page.id, :hide => 0, :layout => 'login', :alias => 'login', :slug => 'login', :uri => 'login') if !Caboose::Page.exists?(:alias => 'login')
+    login_page = Caboose::Page.where(:alias => 'login').first
+        
+    Caboose::PagePermission.create(:role_id => elo_role.id, :page_id => home_page.id  , :action => 'view') if !Caboose::PagePermission.exists?(:role_id => elo_role.id, :page_id => home_page.id  , :action => 'view') 
+    Caboose::PagePermission.create(:role_id => elo_role.id, :page_id => login_page.id , :action => 'view') if !Caboose::PagePermission.exists?(:role_id => elo_role.id, :page_id => login_page.id , :action => 'view')
+    
+    # Create a default post category
+    Caboose::PostCategory.create(:name => 'General News') if !Caboose::PostCategory.exists?(:name => 'General News')
+    
+    # Create the required settings
+    Caboose::Setting.create(:name => 'version'     , :value => Caboose::VERSION        ) if !Caboose::Setting.exists?(:name => 'version'     , :value => Caboose::VERSION        )
+    Caboose::Setting.create(:name => 'site_name'   , :value => 'New Caboose Site'      ) if !Caboose::Setting.exists?(:name => 'site_name'   , :value => 'New Caboose Site'      )
+    Caboose::Setting.create(:name => 'site_url'    , :value => 'www.mycaboosesite.com' ) if !Caboose::Setting.exists?(:name => 'site_url'    , :value => 'www.mycaboosesite.com' )
+    Caboose::Setting.create(:name => 'admin_email' , :value => 'william@nine.is'       ) if !Caboose::Setting.exists?(:name => 'admin_email' , :value => 'william@nine.is'       )
+    
+  end
+end

data/app/models/caboose/utilities/schema.rb

@@ -0,0 +1,106 @@
+
+class Caboose::Utilities::Schema
+   
+  # Tables (in order) that were renamed in the development of the gem.
+  def self.renamed_tables
+    return nil
+  end
+  
+  # Any column indexes that need to exist in the database
+  def self.indexes
+    return nil      
+  end      
+  
+  # The schema of the database
+  # { Model => [[name, data_type, options]] }
+  def self.schema
+    raise NotImplementedError.new("You must implement this")
+  end
+  
+  # Loads initial data into the database
+  def self.load_data
+  end
+    
+  #===========================================================================
+  # Methods that extended classes will use
+  #===========================================================================
+  
+  # Verifies (non-destructively) that the given schema exists in the database.
+  def self.create_schema
+    return if self.schema.nil?
+    
+    rename_tables            
+    c = ActiveRecord::Base.connection
+    self.schema.each do |model, columns|
+      tbl = model.table_name
+      #puts "Creating table #{tbl}..."
+      c.create_table tbl if !c.table_exists?(tbl)
+      columns.each do |col|
+        #puts "Creating column #{tbl}.#{col[0]}..."                 
+        
+        # Skip if the column exists with the proper data type
+        next if c.column_exists?(tbl, col[0], col[1])
+        
+        # If the column doesn't exists, add it
+        if !c.column_exists?(tbl, col[0])
+          if col.count > 2                      
+            c.add_column tbl, col[0], col[1], col[2]
+          else          
+            c.add_column tbl, col[0], col[1] 
+          end
+          
+        # Column exists, but not with the correct data type, try to change it
+        else
+          
+          # Add a temp column
+          if col.count > 2
+            c.add_column tbl, "#{col[0]}_temp", col[1], col[2]
+          else
+            c.add_column tbl, "#{col[0]}_temp", col[1]
+          end
+          
+          # Copy the old column and cast with correct data type to the new column
+          model.all.each do |m|            
+            m["#{col[0]}_temp"] = case col[1]
+              when :integer  then m[col[0]].to_i
+              when :string   then m[col[0]].to_s
+              when :text     then m[col[0]].to_s
+              when :numeric  then m[col[0]].to_f
+              when :datetime then DateTime.parse(m[col[0]])
+              when :boolean  then m[col[0]].to_i == 1
+              else nil
+              end
+            m.save
+          end
+          
+          # Remove the old column and rename the new one
+          c.remove_column tbl, col[0]
+          c.rename_column tbl, "#{col[0]}_temp", col[0]        
+    
+        end
+      end
+    end      
+    create_indexes
+  end
+  
+  # Verifies (non-destructively) that the given indexes exist in the database.
+  def self.create_indexes
+    return if self.indexes.nil?
+    c = ActiveRecord::Base.connection      
+    self.indexes.each do |table, indexes|
+      indexes.each do |index|
+        c.add_index table, index if !c.index_exists?(table, index)
+      end
+    end
+  end
+  
+  # Renames a set of tables 
+  def self.rename_tables
+    return if self.renamed_tables.nil?
+    c = ActiveRecord::Base.connection
+    self.renamed_tables.each do |old_name, new_name|
+      c.rename_table old_name, new_name if c.table_exists?(old_name)
+    end
+  end    
+  
+end

data/lib/caboose/engine.rb

@@ -48,58 +48,6 @@ module Caboose
     return obj.to_json
   end
   
-  # Verifies (non-destructively) that the given schema exists in the database.
-  def Caboose.create_schema(schema)
-    c = ActiveRecord::Base.connection
-    schema.each do |model, columns|
-      tbl = model.table_name
-      c.create_table tbl if !c.table_exists?(tbl)
-      columns.each do |col|        
-        
-        # Skip if the column exists with the proper data type
-        next if c.column_exists?(tbl, col[0], col[1])
-        
-        # If the column doesn't exists, add it
-        if !c.column_exists?(tbl, col[0])
-          if col.count > 2                      
-            c.add_column tbl, col[0], col[1], col[2]
-          else          
-            c.add_column tbl, col[0], col[1] 
-          end
-          
-        # Column exists, but not with the correct data type, try to change it
-        else
-          
-          # Add a temp column
-          if col.count > 2
-            c.add_column tbl, "#{col[0]}_temp", col[1], col[2]
-          else
-            c.add_column tbl, "#{col[0]}_temp", col[1]
-          end
-          
-          # Copy the old column and cast with correct data type to the new column
-          model.all.each do |m|            
-            m["#{col[0]}_temp"] = case col[1]
-              when :integer  then m[col[0]].to_i
-              when :string   then m[col[0]].to_s
-              when :text     then m[col[0]].to_s
-              when :numeric  then m[col[0]].to_f
-              when :datetime then DateTime.parse(m[col[0]])
-              when :boolean  then m[col[0]].to_i == 1
-              else nil
-              end
-            m.save
-          end
-          
-          # Remove the old column and rename the new one
-          c.remove_column tbl, col[0]
-          c.rename_column tbl, "#{col[0]}_temp", col[0]        
-
-        end
-      end
-    end
-  end
-  
   # Strips html and returns the text that breaks closest to the given length
   def Caboose.teaser_text(str, length = 100)
     return "" if str.nil?    

data/lib/caboose/version.rb

@@ -1,3 +1,3 @@
 module Caboose
-  VERSION = '0.2.95'
+  VERSION = '0.2.96'
 end

data/lib/tasks/caboose.rake

@@ -1,15 +1,27 @@
 require "caboose/version"
 require "caboose/migrations"
 
-namespace :caboose do
+namespace :caboose do  
+  
+  desc "Creates/verifies that all database tables and fields are correctly added."
+  task :db => :environment do
+    Caboose::Schema.create_schema
+    Caboose::Schema.load_data
+  end
+
+  desc "Creates all caboose tables"
+  task :create_schema => :environment do Caboose::Schema.create_schema end
+
+  desc "Loads data into caboose tables"
+  task :load_data => :environment do Caboose::Schema.load_data end
 
+  #=============================================================================
+  
   desc "Resets the admin password to 'caboose'"
-  task :reset_admin_pass => :environment do
-    
+  task :reset_admin_pass => :environment do  
     admin_user = Caboose::User.where(username: 'admin').first
     admin_user.password = Digest::SHA1.hexdigest(Caboose::salt + 'caboose')
-    admin_user.save
-    
+    admin_user.save    
   end
 
   desc "Sync production db to development"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: caboose-cms
 version: !ruby/object:Gem::Version
-  version: 0.2.95
+  version: 0.2.96
 platform: ruby
 authors:
 - William Barry
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-03 00:00:00.000000000 Z
+date: 2013-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -181,6 +181,7 @@ files:
 - app/models/caboose/authenticator.rb
 - app/models/caboose/caboose_plugin.rb
 - app/models/caboose/core_plugin.rb
+- app/models/caboose/database_session.rb
 - app/models/caboose/menu_block.rb
 - app/models/caboose/page.rb
 - app/models/caboose/page_bar_generator.rb
@@ -194,9 +195,11 @@ files:
 - app/models/caboose/role.rb
 - app/models/caboose/role_membership.rb
 - app/models/caboose/role_permission.rb
+- app/models/caboose/schema.rb
 - app/models/caboose/setting.rb
 - app/models/caboose/std_class.rb
 - app/models/caboose/user.rb
+- app/models/caboose/utilities/schema.rb
 - app/views/caboose/admin/index.html.erb
 - app/views/caboose/application/show.html.erb
 - app/views/caboose/extras/error.html.erb
@@ -266,7 +269,6 @@ files:
 - lib/sample_files/login.css
 - lib/sample_files/tinymce.yml
 - lib/tasks/caboose.rake
-- lib/tasks/caboose_db.rake
 - MIT-LICENSE
 - Rakefile
 - README.md

data/lib/tasks/caboose_db.rake

@@ -1,228 +0,0 @@
-require "caboose/version"
-require "caboose/migrations"
-
-namespace :caboose do
-
-  desc "Creates/verifies that all database tables and fields are correctly added."
-  task :db => :environment do
-    create_tables
-    load_data
-  end
-  
-  desc "Drops all caboose tables"
-  task :drop_tables => :environment do drop_tables end
-
-  desc "Creates all caboose tables"
-  task :create_tables => :environment do create_tables end
-
-  desc "Loads data into caboose tables"
-  task :load_data => :environment do load_data end
-  
-  #=============================================================================
-  
-  def drop_tables            
-    puts "Dropping any existing caboose tables..."
-    c = ActiveRecord::Base.connection  
-    c.drop_table :users                if c.table_exists?('users')
-    c.drop_table :roles                if c.table_exists?('roles')
-    c.drop_table :permissions          if c.table_exists?('permissions')
-    c.drop_table :roles_users          if c.table_exists?('roles_users')
-    c.drop_table :permissions_roles    if c.table_exists?('permissions_roles')
-    c.drop_table :assets               if c.table_exists?('assets')
-    c.drop_table :pages                if c.table_exists?('pages')
-    c.drop_table :posts                if c.table_exists?('posts')
-    c.drop_table :page_permissions     if c.table_exists?('page_permissions')
-    c.drop_table :sessions             if c.table_exists?('sessions')
-    c.drop_table :settings             if c.table_exists?('settings')
-  end
-
-  def create_tables  
-    puts "Creating required caboose tables..."
-    
-    c = ActiveRecord::Base.connection
-    
-    # Users     
-  	c.create_table :users if !c.table_exists?(:users)  	
-    c.add_column   :users, :first_name             , :string     if !c.column_exists?(:users, :first_name          )     
-    c.add_column   :users, :last_name              , :string     if !c.column_exists?(:users, :last_name           ) 
-    c.add_column   :users, :username               , :string     if !c.column_exists?(:users, :username            ) 
-    c.add_column   :users, :email                  , :string     if !c.column_exists?(:users, :email               ) 
-    c.add_column   :users, :phone                  , :string     if !c.column_exists?(:users, :phone               ) 
-    c.add_column   :users, :password               , :string     if !c.column_exists?(:users, :password            ) 
-    c.add_column   :users, :password_reset_id      , :string     if !c.column_exists?(:users, :password_reset_id   ) 
-    c.add_column   :users, :password_reset_sent    , :datetime   if !c.column_exists?(:users, :password_reset_sent ) 
-    c.add_column   :users, :token                  , :string     if !c.column_exists?(:users, :token               ) 
-    c.add_column   :users, :date_created           , :datetime   if !c.column_exists?(:users, :date_created        ) 
-    
-    # Roles
-    c.create_table :roles if !c.table_exists?(:roles)
-    c.add_column   :roles, :parent_id    , :integer  if !c.column_exists?(:roles, :parent_id   ) 
-    c.add_column   :roles, :name         , :string   if !c.column_exists?(:roles, :name        )
-    c.add_column   :roles, :description  , :string   if !c.column_exists?(:roles, :description )
-    
-    # Permissions
-    c.create_table :permissions if !c.table_exists?(:permissions)
-    c.add_column   :permissions, :resource , :string if !c.column_exists?(:permissions, :resource ) 
-    c.add_column   :permissions, :action   , :string if !c.column_exists?(:permissions, :action   )     
-    
-    # Role membership
-    c.rename_table :roles_users, :role_memberships if c.table_exists?(:roles_users)
-    c.create_table :role_memberships if !c.table_exists?(:role_memberships)
-    c.add_column   :role_memberships, :role_id, :integer if !c.column_exists?(:role_memberships, :role_id)
-    c.add_column   :role_memberships, :user_id, :integer if !c.column_exists?(:role_memberships, :user_id)    
-    c.add_index    :role_memberships, :role_id           if !c.index_exists?( :role_memberships, :role_id)
-    c.add_index    :role_memberships, :user_id           if !c.index_exists?( :role_memberships, :user_id)
-    
-    # Role permissions    
-    c.rename_table :permissions_roles, :role_permissions if c.table_exists?(:permissions_roles)
-    c.create_table :role_permissions if !c.table_exists?(:role_permissions)
-		c.add_column   :role_permissions, :role_id        , :integer if !c.column_exists?(:role_permissions, :role_id       )
-		c.add_column   :role_permissions, :permission_id  , :integer if !c.column_exists?(:role_permissions, :permission_id )		
-		c.add_index    :role_permissions, :role_id                   if !c.index_exists?( :role_permissions, :role_id       )
-		c.add_index    :role_permissions, :permission_id             if !c.index_exists?( :role_permissions, :permission_id )
-    
-    # Assets
-    c.create_table :assets if !c.table_exists?(:assets)
-    c.add_column   :assets, :page_id        , :integer    if !c.column_exists?(:assets, :page_id       )  
-    c.add_column   :assets, :user_id        , :integer    if !c.column_exists?(:assets, :user_id       ) 
-    c.add_column   :assets, :date_uploaded  , :datetime   if !c.column_exists?(:assets, :date_uploaded ) 
-    c.add_column   :assets, :name           , :string     if !c.column_exists?(:assets, :name          ) 
-    c.add_column   :assets, :filename       , :string     if !c.column_exists?(:assets, :filename      ) 
-    c.add_column   :assets, :description    , :string     if !c.column_exists?(:assets, :description   ) 
-    c.add_column   :assets, :extension      , :string     if !c.column_exists?(:assets, :extension     ) 
-    
-    # Pages
-    c.create_table :pages if !c.table_exists?(:pages)
-    c.add_column   :pages, :parent_id             , :integer                                                    if !c.column_exists?(:pages, :parent_id            ) 
-    c.add_column   :pages, :title                 , :string                                                     if !c.column_exists?(:pages, :title                )
-    c.add_column   :pages, :menu_title            , :string                                                     if !c.column_exists?(:pages, :menu_title           )
-    c.add_column   :pages, :content               , :text                                                       if !c.column_exists?(:pages, :content              )
-    c.add_column   :pages, :slug                  , :string                                                     if !c.column_exists?(:pages, :slug                 )
-    c.add_column   :pages, :alias                 , :string                                                     if !c.column_exists?(:pages, :alias                )
-    c.add_column   :pages, :uri                   , :string                                                     if !c.column_exists?(:pages, :uri                  )
-    c.add_column   :pages, :redirect_url          , :string                                                     if !c.column_exists?(:pages, :redirect_url         )
-    c.add_column   :pages, :hide                  , :boolean , :default => false                                if !c.column_exists?(:pages, :hide                 )
-    c.add_column   :pages, :content_format        , :integer , :default => Caboose::Page::CONTENT_FORMAT_HTML   if !c.column_exists?(:pages, :content_format       )
-    c.add_column   :pages, :custom_css            , :text                                                       if !c.column_exists?(:pages, :custom_css           )
-    c.add_column   :pages, :custom_js             , :text                                                       if !c.column_exists?(:pages, :custom_js            )
-    c.add_column   :pages, :linked_resources      , :text                                                       if !c.column_exists?(:pages, :linked_resources     )
-    c.add_column   :pages, :layout                , :string                                                     if !c.column_exists?(:pages, :layout               )
-    c.add_column   :pages, :sort_order            , :integer , :default => 0                                    if !c.column_exists?(:pages, :sort_order           )
-    c.add_column   :pages, :custom_sort_children  , :boolean , :default => false                                if !c.column_exists?(:pages, :custom_sort_children )
-    c.add_column   :pages, :seo_title             , :string  , :limit => 70                                     if !c.column_exists?(:pages, :seo_title            )
-    c.add_column   :pages, :meta_description      , :string  , :limit => 156                                    if !c.column_exists?(:pages, :meta_description     )
-    c.add_column   :pages, :meta_robots           , :string  , :default => 'index, follow'                      if !c.column_exists?(:pages, :meta_robots          )
-    c.add_column   :pages, :canonical_url         , :string                                                     if !c.column_exists?(:pages, :canonical_url        )
-    c.add_column   :pages, :fb_description        , :string  , :limit => 156                                    if !c.column_exists?(:pages, :fb_description       )
-    c.add_column   :pages, :gp_description        , :string  , :limit => 156                                    if !c.column_exists?(:pages, :gp_description       )
-    
-    # Posts
-    c.create_table :posts if !c.table_exists?(:posts)
-    c.add_column   :posts, :title       , :text     if !c.column_exists?(:posts, :title      )  		 	 
-    c.add_column   :posts, :body        , :text 		if !c.column_exists?(:posts, :body       )  	 
-    c.add_column   :posts, :hide        , :boolean  if !c.column_exists?(:posts, :hide       ) 	 
-    c.add_column   :posts, :image_url   , :text 		if !c.column_exists?(:posts, :image_url  )
-    c.add_column   :posts, :created_at  , :datetime if !c.column_exists?(:posts, :created_at )
-    c.add_column   :posts, :updated_at  , :datetime if !c.column_exists?(:posts, :updated_at )
-    
-    # Post categories
-    c.create_table :post_categories if !c.table_exists?(:post_categories)
-    c.add_column   :post_categories, :name , :string if !c.column_exists?(:post_categories, :name)
-    
-    # Post category membership
-    c.create_table :post_category_memberships if !c.table_exists?(:post_category_memberships)
-    c.add_column   :post_category_memberships, :post_id          , :integer if !c.column_exists?(:post_category_memberships, :post_id          )
-    c.add_column   :post_category_memberships, :post_category_id , :integer if !c.column_exists?(:post_category_memberships, :post_category_id )    
-    c.add_index    :post_category_memberships, :post_id                     if !c.index_exists?( :post_category_memberships, :post_id          )
-    c.add_index    :post_category_memberships, :post_category_id            if !c.index_exists?( :post_category_memberships, :post_category_id )
-
-    # Page permissions
-    c.create_table :page_permissions if !c.table_exists?(:page_permissions)
-    c.add_column   :page_permissions, :role_id , :integer  if !c.column_exists?(:page_permissions, :role_id )  
-    c.add_column   :page_permissions, :page_id , :integer  if !c.column_exists?(:page_permissions, :page_id )
-    c.add_column   :page_permissions, :action  , :string   if !c.column_exists?(:page_permissions, :action  )   
-    
-    # Sessions
-    c.create_table :sessions if !c.table_exists?(:sessions)
-    c.add_column   :sessions, :session_id  , :string   , :null => false if !c.column_exists?(:sessions, :session_id )
-    c.add_column   :sessions, :data        , :text                      if !c.column_exists?(:sessions, :data       )
-    c.add_column   :sessions, :created_at  , :datetime , :null => true  if !c.column_exists?(:sessions, :created_at )
-    c.add_column   :sessions, :updated_at  , :datetime , :null => true  if !c.column_exists?(:sessions, :updated_at )    
-    c.add_index    :sessions, :session_id                               if !c.index_exists?( :sessions, :session_id )
-    c.add_index    :sessions, :updated_at                               if !c.index_exists?( :sessions, :updated_at )
-    
-    # Settings
-    c.create_table :settings if !c.table_exists?(:settings)
-    c.add_column   :settings, :name  , :string if !c.column_exists?(:settings, :name  )
-    c.add_column   :settings, :value , :text   if !c.column_exists?(:settings, :value )    
-		
-  end
-  
-  def load_data
-    puts "Loading data into caboose tables..."
-    
-    admin_user = nil
-    if !Caboose::User.exists?(:username => 'admin')
-      admin_user = Caboose::User.create(:first_name => 'Admin', :last_name => 'User', :username => 'admin', :email => 'william@nine.is')
-      admin_user.password = Digest::SHA1.hexdigest(Caboose::salt + 'caboose')
-      admin_user.save
-    end
-    admin_user = Caboose::User.where(:username => 'admin').first if admin_user.nil?
-    
-    Caboose::Role.create(:parent_id => -1           , :name => 'Admin'               ) if !Caboose::Role.exists?(:name =>  'Admin'               ) 
-    Caboose::Role.create(:parent_id => -1           , :name => 'Everyone Logged Out' ) if !Caboose::Role.exists?(:name =>  'Everyone Logged Out' ) 
-    Caboose::Role.create(:parent_id => elo_role.id  , :name => 'Everyone Logged In'  ) if !Caboose::Role.exists?(:name =>  'Everyone Logged In'  ) 
-    
-    admin_role  = Caboose::Role.where(:name => 'Admin'               ).first
-    elo_role    = Caboose::Role.where(:name => 'Everyone Logged Out' ).first
-    eli_role    = Caboose::Role.where(:name => 'Everyone Logged In'  ).first
-    
-    Caboose::User.create(:first_name => 'John', :last_name => 'Doe', :username => 'elo', :email => 'william@nine.is') if !Caboose::User.exists?(:username => 'elo')
-    elo_user = Caboose::User.where(:username => 'elo').first
-     
-    Caboose::Permission.create(:resource => 'all'         , :action => 'all'    ) if !Caboose::Permission.exists?(:resource => 'all'	       , :action => 'all'    )
-    Caboose::Permission.create(:resource => 'users'	      , :action => 'view'   ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'view'   )
-    Caboose::Permission.create(:resource => 'users'	      , :action => 'edit'   ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'edit'   )
-    Caboose::Permission.create(:resource => 'users'	      , :action => 'delete' ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'delete' )
-    Caboose::Permission.create(:resource => 'users'	      , :action => 'add'    ) if !Caboose::Permission.exists?(:resource => 'users'	     , :action => 'add'    )
-    Caboose::Permission.create(:resource => 'roles'	      , :action => 'view'   ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'view'   )
-    Caboose::Permission.create(:resource => 'roles'	      , :action => 'edit'   ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'edit'   )
-    Caboose::Permission.create(:resource => 'roles'	      , :action => 'delete' ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'delete' )
-    Caboose::Permission.create(:resource => 'roles'	      , :action => 'add'    ) if !Caboose::Permission.exists?(:resource => 'roles'	     , :action => 'add'    )
-    Caboose::Permission.create(:resource => 'permissions' , :action => 'view'   ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'view'   )
-    Caboose::Permission.create(:resource => 'permissions' , :action => 'edit'   ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'edit'   )
-    Caboose::Permission.create(:resource => 'permissions' , :action => 'delete' ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'delete' )
-    Caboose::Permission.create(:resource => 'permissions' , :action => 'add'    ) if !Caboose::Permission.exists?(:resource => 'permissions' , :action => 'add'    )
-
-    # Add the admin user to the admin role
-    Caboose::RoleMembership.create(:user_id => admin_user.id, :role_id => admin_role.id) if !Caboose::RoleMembership.exists?(:user_id => admin_user.id, :role_id => admin_role.id)
-    
-    # Add the elo to the elo role
-    Caboose::RoleMembership.create(:user_id => elo_user.id, :role_id => elo_role.id) if !Caboose::RoleMembership.exists?(:user_id => elo_user.id, :role_id => elo_role.id)
-
-    # Add the all/all permission to the admin role
-    admin_perm = Caboose::Permission.where(:resource => 'all', :action => 'all').first
-    Caboose::RolePermission.create(:role_id => admin_role.id, :permission_id => admin_perm.id) if !Caboose::RolePermission.exists?(:role_id => admin_role.id, :permission_id => admin_perm.id)
-    
-    # Create the necessary pages
-    Caboose::Page.create(:title => 'Home'  , :parent_id => -1, :hide => 0, :layout => 'home', :uri => '') if !Caboose::Page.exists?(:title => 'Home')
-    home_page = Caboose::Page.where(:title => 'Home', :parent_id => -1).first
-    Caboose::Page.create(:title => 'Admin' , :parent_id => home_page.id, :hide => 0, :layout => 'admin', :alias => 'admin', :slug => 'admin', :uri => 'admin') if !Caboose::Page.exists?(:alias => 'admin')
-    admin_page = Caboose::Page.where(:alias => 'admin').first
-    Caboose::Page.create(:title => 'Login' , :parent_id => home_page.id, :hide => 0, :layout => 'login', :alias => 'login', :slug => 'login', :uri => 'login') if !Caboose::Page.exists?(:alias => 'login')
-    login_page = Caboose::Page.where(:alias => 'login').first
-        
-    Caboose::PagePermission.create(:role_id => elo_role.id, :page_id => home_page.id  , :action => 'view') if !Caboose::PagePermission.exists?(:role_id => elo_role.id, :page_id => home_page.id  , :action => 'view') 
-    Caboose::PagePermission.create(:role_id => elo_role.id, :page_id => login_page.id , :action => 'view') if !Caboose::PagePermission.exists?(:role_id => elo_role.id, :page_id => login_page.id , :action => 'view')
-    
-    # Create a default post category
-    Caboose::PostCategory.create(:name => 'General News') if !Caboose::PostCategory.exists?(:name => 'General News')
-    
-    # Create the required settings
-    Caboose::Setting.create(:name => 'version'     , :value => Caboose::VERSION        ) if !Caboose::Setting.exists?(:name => 'version'     , :value => Caboose::VERSION        )
-    Caboose::Setting.create(:name => 'site_name'   , :value => 'New Caboose Site'      ) if !Caboose::Setting.exists?(:name => 'site_name'   , :value => 'New Caboose Site'      )
-    Caboose::Setting.create(:name => 'site_url'    , :value => 'www.mycaboosesite.com' ) if !Caboose::Setting.exists?(:name => 'site_url'    , :value => 'www.mycaboosesite.com' )
-    Caboose::Setting.create(:name => 'admin_email' , :value => 'william@nine.is'       ) if !Caboose::Setting.exists?(:name => 'admin_email' , :value => 'william@nine.is'       )
-    
-  end
-end