radiant 0.5.2 → 0.6.0

data/lib/radiant/setup.rb

@@ -0,0 +1,209 @@
+require "highline"
+require "forwardable"
+
+module Radiant
+  class Setup
+  
+    class << self
+      def bootstrap(config)
+        setup = new
+        setup.bootstrap(config)
+        setup
+      end
+    end
+    
+    attr_accessor :config
+    
+    def bootstrap(config)
+      @config = config
+      @admin = create_admin_user(config[:admin_name], config[:admin_username], config[:admin_password])
+      UserActionObserver.current_user = @admin
+      load_default_configuration
+      load_database_template(config[:database_template])
+      announce "Finished.\n\n"
+    end
+    
+    def create_admin_user(name, username, password)
+      unless name and username and password
+        announce "Create the admin user (press enter for defaults)."
+        name = prompt_for_admin_name unless name
+        username = prompt_for_admin_username unless username
+        password = prompt_for_admin_password unless password
+      end
+      attributes = {
+        :name => name,
+        :login => username,
+        :password => password,
+        :password_confirmation => password,
+        :admin => true
+      }
+      admin = User.find_by_login(username)
+      admin = User.new unless admin
+      admin.update_attributes(attributes)
+      admin
+    end
+    
+    def load_default_configuration
+      feedback "\nInitializing configuration" do
+        step { Radiant::Config['admin.title'   ] = 'Radiant CMS' }
+        step { Radiant::Config['admin.subtitle'] = 'Publishing for Small Teams' }
+        step { Radiant::Config['defaults.page.parts' ] = 'body, extended' }
+        step { Radiant::Config['defaults.page.status' ] = 'draft' }
+      end
+    end
+    
+    def load_database_template(filename)
+      template = nil
+      if filename
+        name = find_template_in_path(filename)
+        unless name
+          announce "Invalid template name: #{filename}"
+          filename = nil
+        else
+          template = load_template_file(name)
+        end
+      end
+      unless filename
+        templates = find_and_load_templates("#{RADIANT_ROOT}/db/templates/*.yml")
+        choose do |menu|
+          menu.header = "\nSelect a database template"
+          menu.prompt = "[1-#{templates.size}]: "
+          menu.select_by = :index
+          templates.each { |t| menu.choice(t['name']) { template = t } }
+        end
+      end
+      create_records(template)
+    end
+        
+    private
+      
+      def prompt_for_admin_name
+        username = ask('Name (Administrator): ', String) do |q|
+          q.validate = /^.{0,100}$/
+          q.responses[:not_valid] = "Invalid name. Must be at less than 100 characters long."
+          q.whitespace = :strip
+        end
+        username = "Administrator" if username.blank?
+        username
+      end
+      
+      def prompt_for_admin_username
+        username = ask('Username (admin): ', String) do |q|
+          q.validate = /^(|.{3,40})$/
+          q.responses[:not_valid] = "Invalid username. Must be at least 3 characters long."
+          q.whitespace = :strip
+        end
+        username = "admin" if username.blank?
+        username
+      end
+      
+      def prompt_for_admin_password
+        password = ask('Password (radiant): ', String) do |q|
+          q.echo = false
+          q.validate = /^(|.{5,40})$/
+          q.responses[:not_valid] = "Invalid password. Must be at least 5 characters long."
+          q.whitespace = :strip
+        end
+        password = "radiant" if password.blank?
+        password
+      end
+      
+      def find_template_in_path(filename)
+        [
+          filename,
+          "#{RADIANT_ROOT}/#{filename}",
+          "#{RADIANT_ROOT}/db/templates/#{filename}",
+          "#{RAILS_ROOT}/#{filename}",
+          "#{RAILS_ROOT}/db/templates/#{filename}",
+          "#{Dir.pwd}/#{filename}",
+          "#{Dir.pwd}/db/templates/#{filename}",
+        ].find { |name| File.file?(name) }
+      end
+      
+      def find_and_load_templates(glob)
+        templates = Dir[glob]
+        templates.map! { |template| load_template_file(template) }
+        templates.sort_by { |template| template['name'] }
+      end
+      
+      def load_template_file(filename)
+        YAML.load_file(filename)
+      end
+      
+      def create_records(template)
+        records = template['records']
+        if records
+          puts
+          records.keys.each do |key|
+            feedback "Creating #{key.to_s.underscore.humanize}" do
+              model = model(key)
+              model.reset_column_information
+              record_pairs = order_by_id(records[key])
+              step do
+                record_pairs.each do |id, record|
+                  model.new(record).save
+                end
+              end
+            end
+          end
+        end
+      end
+      
+      def model(model_name)
+        model_name.to_s.singularize.constantize
+      end
+      
+      def order_by_id(records)
+        records.map { |name, record| [record['id'], record] }.sort { |a, b| a[0] <=> b[0] }
+      end
+      
+      extend Forwardable
+      def_delegators :terminal, :agree, :ask, :choose, :say
+  
+      def terminal
+        @terminal ||= HighLine.new
+      end
+  
+      def output
+        terminal.instance_variable_get("@output")
+      end
+  
+      def wrap(string)
+        string = terminal.send(:wrap, string) unless terminal.wrap_at.nil?
+        string
+      end
+  
+      def print(string)
+        output.print(wrap(string))
+        output.flush
+      end
+  
+      def puts(string = "\n")
+        say string
+      end
+  
+      def announce(string)
+        puts "\n#{string}"
+      end
+            
+      def feedback(process, &block)
+        print "#{process}..."
+        if yield
+          puts "OK"
+          true
+        else
+          puts "FAILED"
+          false
+        end
+      rescue Exception => e
+        puts "FAILED"
+        raise e
+      end
+      
+      def step
+        yield if block_given?
+        print '.'
+      end
+      
+  end
+end

data/lib/radiant/taggable.rb

@@ -0,0 +1,74 @@
+module Radiant::Taggable
+  mattr_accessor :last_description, :tag_descriptions
+  @@tag_descriptions = {}
+    
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.module_eval do
+      def self.included(new_base)
+        super
+        new_base.tag_descriptions.merge! self.tag_descriptions
+      end
+    end
+  end
+  
+  def render_tag(name, tag_binding)
+    send "tag:#{name}", tag_binding
+  end
+  
+  def tags
+    Util.tags_in_array(methods)
+  end
+  
+  def tag_descriptions(hash=nil)
+    self.class.tag_descriptions hash
+  end
+  
+  module ClassMethods
+    def inherited(subclass)
+      subclass.tag_descriptions.reverse_merge! self.tag_descriptions
+      super
+    end
+    
+    def tag_descriptions(hash = nil)
+      Radiant::Taggable.tag_descriptions[self.name] ||= (hash ||{})
+    end
+  
+    def desc(text)
+      Radiant::Taggable.last_description = RedCloth.new(Util.strip_leading_whitespace(text)).to_html
+    end
+    
+    def tag(name, &block)
+      self.tag_descriptions[name] = Radiant::Taggable.last_description if Radiant::Taggable.last_description
+      Radiant::Taggable.last_description = nil
+      define_method("tag:#{name}", &block)
+    end
+    
+    def tags
+      Util.tags_in_array(self.instance_methods)
+    end
+    
+  end
+   
+  module Util
+    def self.tags_in_array(array)
+      array.grep(/^tag:/).map { |name| name[4..-1] }.sort
+    end
+    
+    def self.strip_leading_whitespace(text)
+      text = text.dup
+      text.gsub!("\t", "  ")
+      lines = text.split("\n")
+      leading = lines.map do |line|
+        unless line =~ /^\s*$/
+           line.match(/^(\s*)/)[0].length
+        else
+          nil
+        end
+      end.compact.min
+      lines.inject([]) {|ary, line| ary << line.sub(/^[ ]{#{leading}}/, "")}.join("\n")
+    end      
+    
+  end
+  
+end

data/lib/simpleton.rb

@@ -0,0 +1,21 @@
+module Simpleton
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    
+    def instance(&block)
+      @instance ||= new
+      block.call(@instance) if block_given?
+      @instance
+    end
+    
+    def method_missing(method, *args, &block)
+      instance.respond_to?(method) ? instance.send(method, *args, &block) : super
+    end
+    
+  end
+  
+end

data/lib/tasks/database.rake

@@ -0,0 +1,32 @@
+namespace :db do
+  desc "Migrate schema to version 0 and back up again. WARNING: Destroys all data in tables!!"
+  task :remigrate => :environment do
+    require 'highline/import'
+    if ENV['OVERWRITE'].to_s.downcase == 'true' or
+      agree("This task will destroy any data in the database. Are you sure you want to \ncontinue? [yn] ")
+      
+      # Migrate downward
+      ActiveRecord::Migrator.migrate("#{RADIANT_ROOT}/db/migrate/", 0)
+    
+      # Migrate upward 
+      Rake::Task["db:migrate"].invoke
+      
+      # Dump the schema
+      Rake::Task["db:schema:dump"].invoke
+    else
+      say "Task cancelled."
+      exit
+    end
+  end
+  
+  desc "Bootstrap your database for Radiant."
+  task :bootstrap => :remigrate do
+    require 'radiant/setup'
+    Radiant::Setup.bootstrap(
+      :admin_name => ENV['ADMIN_NAME'],
+      :admin_username => ENV['ADMIN_USERNAME'],
+      :admin_password => ENV['ADMIN_PASSWORD'],
+      :database_template => ENV['DATABASE_TEMPLATE']
+    )
+  end
+end

data/lib/tasks/environments.rake

@@ -0,0 +1,11 @@
+desc "Set the environment variable RAILS_ENV='development'."
+task :development do
+  ENV['RAILS_ENV'] = RAILS_ENV = 'development'
+  Rake::Task[:environment].invoke
+end
+
+desc "Set the environment variable RAILS_ENV='production'."
+task :production do
+  ENV['RAILS_ENV'] = RAILS_ENV = 'production'
+  Rake::Task[:environment].invoke
+end

data/lib/tasks/extensions.rake

@@ -0,0 +1,27 @@
+require 'rake/testtask'
+
+namespace :db do
+  namespace :migrate do
+    desc "Run all Radiant extension migrations"
+    task :extensions => :environment do
+      require 'radiant/extension_migrator'
+      Radiant::ExtensionMigrator.migrate_extensions
+    end
+  end
+end
+
+namespace :test do
+  desc "Runs tests on all available Radiant extensions"
+  task :extensions => "db:test:prepare" do
+    Dir["#{RAILS_ROOT}/vendor/extensions/*"].sort.select { |f| File.directory?(f) }.each do |directory|
+      chdir directory do
+        system "rake test"
+      end
+    end
+  end
+end
+
+# Load any custom rakefiles from extensions
+[RAILS_ROOT, RADIANT_ROOT].uniq.each do |root|
+  Dir[root + '/vendor/extensions/**/tasks/**/*.rake'].sort.each { |ext| load ext }
+end

data/lib/tasks/framework.rake

@@ -0,0 +1,123 @@
+# Only define freeze and unfreeze tasks in instance mode
+unless File.directory? "#{RAILS_ROOT}/app"
+  namespace :radiant do
+    namespace :freeze do
+      desc "Lock this application to the current gems (by unpacking them into vendor/radiant)"
+      task :gems do
+        require 'rubygems'
+        Gem.manage_gems
+
+        radiant = (version = ENV['VERSION']) ?
+          Gem.cache.search('radiant', "= #{version}").first :
+          Gem.cache.search('radiant').sort_by { |g| g.version }.last
+
+        version ||= radiant.version
+
+        unless radiant
+          puts "No radiant gem #{version} is installed.  Do 'gem list radiant' to see what you have available."
+          exit
+        end
+
+        puts "Freezing to the gems for Radiant #{radiant.version}"
+        rm_rf   "vendor/radiant"
+
+        chdir("vendor") do
+          Gem::GemRunner.new.run(["unpack", "-v", "=#{version}", "radiant"])
+          FileUtils.mv(Dir.glob("radiant*").first, "radiant")
+        end
+      end
+
+      desc "Lock to latest Edge Radiant or a specific revision with REVISION=X (ex: REVISION=4021), a tag with TAG=Y (ex: TAG=rel_1-1-0), or a branch with BRANCH=Z (ex: BRANCH=mental)"
+      task :edge do
+        $verbose = false
+        `svn --version` rescue nil
+        unless !$?.nil? && $?.success?
+          $stderr.puts "ERROR: Must have subversion (svn) available in the PATH to lock this application to Edge Radiant"
+          exit 1
+        end
+
+        rm_rf   "vendor/radiant"
+        mkdir_p "vendor/radiant"
+
+        svn_root = "http://dev.radiantcms.org/svn/radiant/"
+
+        case
+        when ENV['TAG']
+          radiant_svn = "#{svn_root}/tags/#{ENV['TAG']}"
+          touch "vendor/radiant/TAG_#{ENV['TAG']}"
+        when ENV['BRANCH']
+          radiant_svn = "#{svn_root}/branches/#{ENV['BRANCH']}"
+          touch "vendor/radiant/BRANCH_#{ENV['BRANCH']}"
+        else
+          radiant_svn = "#{svn_root}/trunk"
+
+          if ENV['REVISION'].nil?
+            ENV['REVISION'] = /^r(\d+)/.match(%x{svn -qr HEAD log #{svn_root}})[1]
+            puts "REVISION not set. Using HEAD, which is revision #{ENV['REVISION']}."
+          end
+
+          touch "vendor/radiant/REVISION_#{ENV['REVISION']}"
+        end
+      
+        system "svn export #{radiant_svn}/radiant vendor/radiant" + (ENV['REVISION'] ? " -r #{ENV['REVISION']}" : "") + " --force"
+      end
+    end
+
+    desc "Unlock this application from freeze of gems or edge and return to a fluid use of system gems"
+    task :unfreeze do
+      rm_rf "vendor/radiant"
+    end
+    
+    desc "Update both configs, scripts and public/javascripts from Radiant"
+    task :update => [ "update:scripts", "update:javascripts", "update:configs", "update:images", "update:stylesheets" ]
+
+    namespace :update do
+      desc "Add new scripts to the instance script/ directory"
+      task :scripts do
+        local_base = "script"
+        edge_base  = "#{File.dirname(__FILE__)}/../../scripts"
+        
+        local = Dir["#{local_base}/**/*"].reject { |path| File.directory?(path) }
+        edge  = Dir["#{edge_base}/**/*"].reject { |path| File.directory?(path) }
+        edge  = edge.reject { |f| f =~ /(generate|plugin|destroy)$/ }
+        
+        edge.each do |script|
+          base_name = script[(edge_base.length+1)..-1]
+          next if local.detect { |path| base_name == path[(local_base.length+1)..-1] }
+          if !File.directory?("#{local_base}/#{File.dirname(base_name)}")
+            mkdir_p "#{local_base}/#{File.dirname(base_name)}"
+          end
+          install script, "#{local_base}/#{base_name}", :mode => 0755
+        end
+        install "#{File.dirname(__FILE__)}/../generators/instance/templates/instance_generate", "#{local_base}/generate", :mode => 0755
+      end
+
+      desc "Update your javascripts from your current radiant install"
+      task :javascripts do
+        project_dir = RAILS_ROOT + '/public/javascripts/'
+        scripts = Dir["#{File.dirname(__FILE__)}/../../public/javascripts/*.js"]
+        scripts.reject!{|s| File.basename(s) == 'application.js'} if File.exists?(project_dir + 'application.js')
+        FileUtils.cp(scripts, project_dir)
+      end
+
+      desc "Update config/boot.rb from your current radiant install"
+      task :configs do
+        FileUtils.cp("#{File.dirname(__FILE__)}/../generators/instance/templates/instance_boot.rb", RAILS_ROOT + '/config/boot.rb')
+      end
+      
+      desc "Update admin images from your current radiant install"
+      task :images do
+        project_dir = RAILS_ROOT + '/public/images/admin/'
+        images = Dir["#{File.dirname(__FILE__)}/../../public/images/admin/*"]
+        FileUtils.cp(images, project_dir)
+      end
+      
+      desc "Update admin stylesheets from your current radiant install"
+      task :stylesheets do
+        project_dir = RAILS_ROOT + '/public/stylesheets/admin/'
+        stylesheets = Dir["#{File.dirname(__FILE__)}/../../public/stylesheets/admin/*.css"]
+        FileUtils.cp(stylesheets, project_dir)
+      end      
+    end
+  end
+end