trusty-cms 1.0.0

data/lib/trusty_cms/resource_responses.rb

@@ -0,0 +1,121 @@
+require 'ostruct'
+module TrustyCms
+  module ResourceResponses
+    def self.extended(base)
+      base.send :class_attribute, :responses
+      base.send :include, InstanceMethods
+    end
+    
+    def responses
+      r = (self.responses = read_inheritable_attribute(:responses) || Collector.new)
+      yield r if block_given?
+      r
+    end
+    
+    module InstanceMethods
+      def response_for(action)
+        responses = self.class.responses.send(action)
+        respond_to do |wants|
+          responses.each_format do |f, format_block|
+            if format_block
+              wants.send(f, &wrap(format_block))
+            else
+              wants.send(f)
+            end
+          end
+          responses.each_published do |pub, pub_block|
+            wants.send(pub, &wrap(pub_block))
+          end
+          if responses.default
+            wants.any(&wrap(responses.default))
+          else
+            wants.any
+          end
+        end
+      end
+      
+      def wrap(proc)
+        # Makes sure our response blocks get evaluated in the right context
+        lambda do
+          # Ruby 1.9.2 yields self in instance_eval... see https://gist.github.com/479572
+          # lambdas are as strict as methods in 1.9.x, making sure that the args match, Procs are not.
+          if RUBY_VERSION =~ /^1\.9/ and proc.lambda? and proc.arity != 1
+            raise "You can only pass a proc ('Proc.new') or a lambda that takes exactly one arg (for self) to the wrap method."
+          end
+          
+          instance_eval(&proc)
+        end
+      end
+    end
+    
+    class Collector < OpenStruct
+      def initialize
+        super
+        @table = Hash.new {|h,k| h[k] = Response.new }
+      end
+      
+      def initialize_copy(orig)
+        super
+        @table.keys.each do |key|
+          @table[key] = orig.send(key).dup
+        end
+      end
+    end
+    
+    class Response
+      attr_reader :publish_formats, :publish_block, :blocks, :block_order
+      def initialize
+        @publish_formats = []
+        @blocks = {}
+        @block_order = []
+      end
+      
+      def initialize_copy(orig)
+        @publish_formats = orig.publish_formats.dup
+        @blocks = orig.blocks.dup
+        @block_order = orig.block_order.dup
+        @publish_block = orig.publish_block.dup if orig.publish_block
+        @default = orig.default.dup if orig.default
+      end
+      
+      def default(&block)
+        if block_given?
+          @default = block
+        end
+        @default
+      end
+      
+      def publish(*formats, &block)
+        @publish_formats.concat(formats)
+        if block_given?
+          @publish_block = block 
+        else
+          raise ArgumentError, "Block required to publish" unless @publish_block
+        end
+      end
+      
+      def each_published
+        publish_formats.each do |format|
+          yield format, publish_block if block_given?
+        end
+      end
+
+      def each_format
+        @block_order.each do |format|
+          yield format, @blocks[format] if block_given?
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if block_given?
+          @blocks[method] = block
+          @block_order << method unless @block_order.include?(method)
+        elsif args.empty?
+          @block_order << method
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/trusty_cms/setup.rb

@@ -0,0 +1,227 @@
+require "highline"
+require "forwardable"
+
+module TrustyCms
+  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."
+    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 { TrustyCms::Config['admin.title'   ] = 'TrustyCms CMS' }
+        step { TrustyCms::Config['admin.subtitle'] = 'Publishing for Small Teams' }
+        step { TrustyCms::Config['defaults.page.parts' ] = 'body, extended' }
+        step { TrustyCms::Config['defaults.page.status' ] = 'Draft' }
+        step { TrustyCms::Config['defaults.page.filter' ] = nil }
+        step { TrustyCms::Config['defaults.page.fields'] = 'Keywords, Description' }
+        step { TrustyCms::Config['session_timeout'] = 2.weeks }
+        step { TrustyCms::Config['default_locale'] = 'en' }
+      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("#{TRUSTY_CMS_ROOT}/db/templates/*.yml")
+        templates.concat find_and_load_templates("#{TRUSTY_CMS_ROOT}/vendor/extensions/**/db/templates/*.yml")
+        TrustyCms::Extension.descendants.each do |d|
+          templates.concat find_and_load_templates(d.root + '/db/templates/*.yml')
+        end
+        templates.concat find_and_load_templates("#{Rails.root}/vendor/extensions/**/db/templates/*.yml")
+        templates.concat find_and_load_templates("#{Rails.root}/db/templates/*.yml")
+        templates.uniq!
+        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 unless defined?(::JRuby) # JRuby doesn't support stty interaction
+          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,
+            "#{TRUSTY_CMS_ROOT}/#{filename}",
+            "#{TRUSTY_CMS_ROOT}/db/templates/#{filename}",
+            "#{Rails.root}/#{filename}",
+            "#{Rails.root}/db/templates/#{filename}",
+            "#{Dir.pwd}/#{filename}",
+            "#{Dir.pwd}/db/templates/#{filename}"
+          ] +
+          Dir.glob("#{TRUSTY_CMS_ROOT}/vendor/extensions/**/db/templates/#{filename}") +
+          Dir.glob("#{Rails.root}/vendor/extensions/**/db/templates/#{filename}") +
+          TrustyCms::Extension.descendants.inject([]) do |r, d|
+            r << "#{d.root}/db/templates/#{filename}"
+          end
+        ).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/trusty_cms/taggable.rb

@@ -0,0 +1,138 @@
+module TrustyCms::Taggable
+  mattr_accessor :last_description, :tag_descriptions, :tag_deprecations
+  @@tag_descriptions = {}
+  @@tag_deprecations = {}
+    
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.module_eval do
+      def self.included(new_base)
+        super
+        new_base.class_eval do
+          include Rails.application.routes.url_helpers
+        end
+        class << new_base
+          def default_url_options
+            {:controller => "site", :action => "show_page", :only_path => true}
+          end
+        end
+        new_base.tag_descriptions.merge! self.tag_descriptions
+      end
+      
+      protected
+        def params
+          @params ||= request.parameters unless request.nil?
+        end
+
+        def request_uri
+          @request_url ||= request.request_uri unless request.nil?
+        end
+    end
+  end
+  
+  def render_tag(name, tag_binding)
+    tag_method_name = "tag:#{name}"
+    tag_method = method(tag_method_name)
+    if tag_method.arity == 0
+      tag_method.call
+    else
+      tag_method.call tag_binding
+    end
+  end
+  
+  def tags
+    Util.tags_in_array(methods)
+  end
+  
+  def tag_descriptions(hash=nil)
+    self.class.tag_descriptions hash
+  end
+  
+  def warn_of_tag_deprecation(tag_name, options={})
+    message = "Deprecated radius tag <r:#{tag_name}>"
+    message << " will be removed or significantly changed in radiant #{options[:deadline]}." if options[:deadline]
+    message << " Please use <r:#{options[:substitute]}> instead." if options[:substitute]
+    ActiveSupport::Deprecation.warn(message)
+  end
+
+  module ClassMethods
+    def inherited(subclass)
+      subclass.tag_descriptions.reverse_merge! self.tag_descriptions
+      super
+    end
+    
+    def tag_descriptions(hash = nil)
+      TrustyCms::Taggable.tag_descriptions[self.name] ||= (hash ||{})
+    end
+
+    def desc(text)
+      TrustyCms::Taggable.last_description = text
+      # TrustyCms::Taggable.last_description = RedCloth.new(Util.strip_leading_whitespace(text)).to_html
+    end
+    
+    def tag(name, &block)
+      self.tag_descriptions[name] = TrustyCms::Taggable.last_description if TrustyCms::Taggable.last_description
+      TrustyCms::Taggable.last_description = nil
+      define_method("tag:#{name}", &block)
+    end
+    
+    def tags
+      Util.tags_in_array(self.instance_methods)
+    end
+    
+    # Define a tag while also deprecating it. Normal usage:
+    #
+    #   deprecated_tag 'old:way', :substitute => 'new:way', :deadline => '1.1.1'
+    #
+    # If no substitute is given then a warning will be issued but nothing rendered. 
+    # If a deadline version is provided then it will be mentioned in the deprecation warnings.
+    #
+    # In less standard situations you can use deprecated_tag in exactly the 
+    # same way as tags are normally defined:
+    #
+    # desc %{
+    #   Please note that the old r:busted namespace is no longer supported. 
+    #   Refer to the documentation for more about the new r:hotness tags.
+    # }
+    # deprecated_tag 'busted' do |tag|
+    #   raise TagError "..."
+    # end
+    #
+    def deprecated_tag(name, options={}, &dblock)
+      TrustyCms::Taggable.tag_deprecations[name] = options.dup
+      if dblock
+        tag(name) do |tag|
+          warn_of_tag_deprecation(name, options)
+          dblock.call(tag)
+        end
+      else
+        tag(name) do |tag|
+          warn_of_tag_deprecation(name, options)
+          tag.render(options[:substitute], tag.attr.dup, &tag.block) if options[:substitute]
+        end
+      end
+    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/trusty_cms/task_support.rb

@@ -0,0 +1,66 @@
+module TrustyCms
+  class TaskSupport
+    class << self
+      def establish_connection
+        unless ActiveRecord::Base.connected?
+          connection_hash = YAML.load_file("#{Rails.root}/config/database.yml").to_hash
+          env_connection = connection_hash[Rails.env]
+          ActiveRecord::Base.establish_connection(env_connection)
+        end
+      end
+      def config_export(path = "#{Rails.root}/config/radiant_config.yml")
+        self.establish_connection
+        FileUtils.mkdir_p(File.dirname(path))
+        if File.open(File.expand_path(path), 'w') { |f| YAML.dump(TrustyCms::Config.to_hash.to_yaml,f) }
+          puts "TrustyCms::Config saved to #{path}"
+        end
+      end
+      def config_import(path = "#{Rails.root}/config/radiant_config.yml", clear = nil)
+        self.establish_connection
+        if File.exist?(path)
+          begin
+            TrustyCms::Config.transaction do
+              TrustyCms::Config.delete_all if clear
+              configs = YAML.load(YAML.load_file(path))
+              configs.each do |key, value|
+                c = TrustyCms::Config.find_or_initialize_by_key(key)
+                c.value = value
+                c.save
+              end
+            end
+            puts "TrustyCms::Config updated from #{path}"
+          rescue ActiveRecord::RecordInvalid => e
+            puts "IMPORT FAILED and rolled back. #{e}"
+          end
+        else
+          puts "No file exists at #{path}"
+        end
+      end
+
+      # Write the combined content of files in dir into cache_file in the same dir.
+      #
+      def cache_files(dir, files, cache_file)
+        cache_content = files.collect { |f|
+          File.read(File.join(dir, f)) }.join("\n\n")
+
+        cache_path = File.join(dir, cache_file)
+        File.delete(cache_path) if File.exists?(cache_path)
+        File.open(cache_path, "w+") { |f| f.write(cache_content) }
+      end
+
+      # Reads through the layout file and returns an array of JS filenames
+      #
+      def find_admin_js
+        layout = "#{TRUSTY_CMS_ROOT}/app/views/layouts/application.html.haml"
+        js_regexp = /javascript_include_tag %w\((.*)\), :cache => 'admin\/all/
+        files = File.open(layout) { |f| f.read.match(js_regexp)[1].split }
+        files.collect { |f| f.split('/').last + '.js' }
+      end
+
+      def cache_admin_js
+        dir = "#{Rails.root}/public/javascripts/admin"
+        cache_files(dir, find_admin_js, 'all.js')
+      end
+    end
+  end
+end

data/lib/trusty_cms.rb

@@ -0,0 +1,19 @@
+TRUSTY_CMS_ROOT = File.expand_path(File.join(File.dirname(__FILE__), "..")) unless defined? TRUSTY_CMS_ROOT
+
+unless defined? TrustyCms::Version
+  module TrustyCms
+    module Version
+      Major = '1'
+      Minor = '0'
+      Tiny  = '0'
+      Patch = nil # set to nil for normal release
+
+      class << self
+        def to_s
+          [Major, Minor, Tiny, Patch].delete_if{|v| v.nil? }.join('.')
+        end
+        alias :to_str :to_s
+      end
+    end
+  end
+end

data/public/.htaccess

@@ -0,0 +1,40 @@
+# General Apache options
+AddHandler fastcgi-script .fcgi
+#AddHandler cgi-script .cgi
+Options +FollowSymLinks +ExecCGI
+
+# If you don't want Rails to look in certain directories,
+# use the following rewrite rules so that Apache won't rewrite certain requests
+# 
+# Example:
+#   RewriteCond %{REQUEST_URI} ^/notrails.*
+#   RewriteRule .* - [L]
+
+# Redirect all requests not available on the filesystem to Rails
+# By default the cgi dispatcher is used which is very slow
+# 
+# For better performance replace the dispatcher with the fastcgi one
+#
+# Example:
+#   RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
+RewriteEngine On
+
+# If your Rails application is accessed via an Alias directive,
+# then you MUST also set the RewriteBase in this htaccess file.
+#
+# Example:
+#   Alias /myrailsapp /path/to/myrailsapp/public
+#   RewriteBase /myrailsapp
+
+RewriteRule ^$ index.html [QSA]
+RewriteRule ^([^.]+)$ $1.html [QSA]
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
+
+# In case Rails experiences terminal errors
+# Instead of displaying this message you can supply a file here which will be rendered instead
+# 
+# Example:
+#   ErrorDocument 500 /500.html
+
+ErrorDocument 500 "<h2>Application error</h2>Rails application failed to start properly"

data/public/404.html

@@ -0,0 +1,8 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body>
+  <h1>File not found</h1>
+  <p>Change this error message for pages not found in public/404.html</p>
+</body>
+</html>

data/public/500.html

@@ -0,0 +1,8 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body>
+  <h1>Application error</h1>
+  <p>Change this error message for exceptions thrown outside of an action (like in Dispatcher setups or broken Ruby code) in public/500.html</p>
+</body>
+</html>

data/public/dispatch.cgi

@@ -0,0 +1,10 @@
+#!/home/rails/bin/ruby
+
+require File.dirname(__FILE__) + "/../config/environment" unless defined?(Rails.root)
+
+# If you're using RubyGems and mod_ruby, this require should be changed to an absolute path one, like:
+# "/usr/local/lib/ruby/gems/1.8/gems/rails-0.8.0/lib/dispatcher" -- otherwise performance is severely impaired
+require "dispatcher"
+
+ADDITIONAL_LOAD_PATHS.reverse.each { |dir| $:.unshift(dir) if File.directory?(dir) } if defined?(Apache::RubyRun)
+Dispatcher.dispatch

data/public/dispatch.fcgi

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+#
+# You may specify the path to the FastCGI crash log (a log of unhandled
+# exceptions which forced the FastCGI instance to exit, great for debugging)
+# and the number of requests to process before running garbage collection.
+#
+# By default, the FastCGI crash log is Rails.root/log/fastcgi.crash.log
+# and the GC period is nil (turned off).  A reasonable number of requests
+# could range from 10-100 depending on the memory footprint of your app.
+#
+# Example:
+#   # Default log path, normal GC behavior.
+#   RailsFCGIHandler.process!
+#
+#   # Default log path, 50 requests between GC.
+#   RailsFCGIHandler.process! nil, 50
+#
+#   # Custom log path, normal GC behavior.
+#   RailsFCGIHandler.process! '/var/log/myapp_fcgi_crash.log'
+#
+require File.dirname(__FILE__) + "/../config/environment"
+require 'fcgi_handler'
+
+RailsFCGIHandler.process!

data/public/dispatch.rb

@@ -0,0 +1,10 @@
+#!/home/rails/bin/ruby
+
+require File.dirname(__FILE__) + "/../config/environment" unless defined?(Rails.root)
+
+# If you're using RubyGems and mod_ruby, this require should be changed to an absolute path one, like:
+# "/usr/local/lib/ruby/gems/1.8/gems/rails-0.8.0/lib/dispatcher" -- otherwise performance is severely impaired
+require "dispatcher"
+
+ADDITIONAL_LOAD_PATHS.reverse.each { |dir| $:.unshift(dir) if File.directory?(dir) } if defined?(Apache::RubyRun)
+Dispatcher.dispatch