trusty-cms 1.0.0

data/app/models/status.rb

@@ -0,0 +1,41 @@
+class Status
+  attr_accessor :id, :name
+
+  def initialize(options = {})
+    options = options.symbolize_keys
+    @id, @name = options[:id], options[:name]
+  end
+  
+  def symbol
+    @name.to_s.downcase.intern
+  end
+  
+  def self.[](value)
+    @@statuses.find { |status| status.symbol == value.to_s.downcase.intern }
+  end
+  
+  def self.find(id)
+    @@statuses.find { |status| status.id.to_s == id.to_s }
+  end
+  
+  def self.find_all
+    @@statuses.dup
+  end
+  
+  def self.selectable
+    find_all - [self['Scheduled']]
+  end
+    
+  def self.selectable_values
+    self.selectable.map(&:name)
+  end
+  
+  @@statuses = [
+    Status.new(:id => 1,   :name => 'Draft'    ),
+    Status.new(:id => 50,  :name => 'Reviewed' ),
+    Status.new(:id => 90,  :name => 'Scheduled'),
+    Status.new(:id => 100, :name => 'Published'),
+    Status.new(:id => 101, :name => 'Hidden'   )
+  ]
+  
+end

data/app/models/text_filter.rb

@@ -0,0 +1,36 @@
+class TextFilter
+  include Simpleton
+  include Annotatable
+  
+  annotate :filter_name, :description
+   
+  def filter(text)
+    text
+  end
+  
+  class << self
+    def inherited(subclass)
+      subclass.filter_name = subclass.name.to_name('Filter')
+    end
+    
+    def filter(text)
+      instance.filter(text)
+    end
+    
+    def description_file(filename)
+      text = File.read(filename) rescue ""
+      self.description text
+    end
+
+    def descendants_names
+      descendants.map { |s| s.filter_name }.sort
+    end
+
+    def find_descendant(filter_name)
+      descendants.each do |s|
+        return s if s.filter_name == filter_name
+      end
+      nil
+    end
+  end
+end

data/app/models/trusty_cms/config.rb

@@ -0,0 +1,313 @@
+module TrustyCms
+
+  class << self
+    def config_definitions
+      @config_definitions ||= {}
+    end
+
+    def config_definitions=(definitions)
+      @config_definitions = definitions
+    end
+  end
+
+  class Config < ActiveRecord::Base
+    require 'trusty_cms/config/definition'
+    #
+    # The TrustyCms.config model class is stored in the database (and cached) but emulates a hash
+    # with simple bracket methods that allow you to get and set values like so:
+    #
+    #   TrustyCms.config['setting.name'] = 'value'
+    #   TrustyCms.config['setting.name'] #=> "value"
+    #
+    # Config entries can be used freely as general-purpose global variables unless a definition
+    # has been given for that key, in which case restrictions and defaults may apply. The restrictions  
+    # can take the form of validations, requirements, permissions or permitted options. They are 
+    # declared by calling TrustyCms::Config#define:
+    # 
+    #   # setting must be either 'foo', 'bar' or 'blank'
+    #   define('admin.name', :select_from => ['foo', 'bar'])
+    #
+    #   # setting is (and must be) chosen from the names of currently available layouts
+    #   define('shop.layout', :select_from => lambda { Layout.all.map{|l| [l.name,l.id]} }, :alow_blank => false)
+    #
+    #   # setting cannot be changed at runtime
+    #   define('setting.important', :default => "something", :allow_change => false)
+    #
+    # Which almost always happens in a block like this:
+    #
+    #   TrustyCms.config do |config|
+    #     config.namespace('user', :allow_change => true) do |user|
+    #       user.define 'allow_password_reset?', :default => true
+    #     end
+    #   end
+    #
+    # and usually in a config/radiant_config.rb file either in radiant itself, in the application directory
+    # or in an extension. TrustyCms currently defines the following settings and makes them editable by
+    # admin users on the site configuration page:
+    #
+    # admin.title               :: the title of the admin system
+    # admin.subtitle            :: the subtitle of the admin system
+    # defaults.page.parts       :: a comma separated list of default page parts
+    # defaults.page.status      :: a string representation of the default page status
+    # defaults.page.filter      :: the default filter to use on new page parts
+    # defaults.page.fields      :: a comma separated list of the default page fields
+    # defaults.snippet.filter   :: the default filter to use on new snippets
+    # dev.host                  :: the hostname where draft pages are viewable
+    # local.timezone            :: the timezone name (`rake -D time` for full list)
+    #                              used to correct displayed times
+    # page.edit.published_date? :: when true, shows the datetime selector
+    #                              for published date on the page edit screen
+    #
+    # Helper methods are defined in ConfigurationHelper that will display config entry values
+    # or edit fields:
+    # 
+    #   # to display label and value, where label comes from looking up the config key in the active locale
+    #   show_setting('admin.name') 
+    #
+    #   # to display an appropriate checkbox, text field or select box with label as above:
+    #   edit_setting('admin.name)
+    #
+    
+    set_table_name "config"
+    after_save :update_cache
+    attr_reader :definition
+    
+    class ConfigError < RuntimeError; end
+    
+    class << self
+      def [](key)
+        if table_exists?
+          unless TrustyCms::Config.cache_file_exists?
+            TrustyCms::Config.ensure_cache_file
+            TrustyCms::Config.initialize_cache
+          end
+          TrustyCms::Config.initialize_cache if TrustyCms::Config.stale_cache?
+          Rails.cache.read('TrustyCms::Config')[key]
+        end
+      end
+
+      def []=(key, value)
+        if table_exists?
+          setting = find_or_initialize_by_key(key)
+          setting.value = value
+        end
+      end
+      
+      def to_hash
+        Hash[ *all.map { |pair| [pair.key, pair.value] }.flatten ]
+      end
+      
+      def initialize_cache
+        TrustyCms::Config.ensure_cache_file
+        Rails.cache.write('TrustyCms::Config',TrustyCms::Config.to_hash)
+        Rails.cache.write('TrustyCms.cache_mtime', File.mtime(cache_file))
+        Rails.cache.silence!
+      end
+      
+      def cache_file_exists?
+        File.file?(cache_file)
+      end
+      
+      def stale_cache?
+        return true unless TrustyCms::Config.cache_file_exists?
+        Rails.cache.read('TrustyCms.cache_mtime') != File.mtime(cache_file)
+      end
+      
+      def ensure_cache_file
+        FileUtils.mkpath(cache_path)
+        FileUtils.touch(cache_file)
+      end
+      
+      def cache_path
+        "#{Rails.root}/tmp"
+      end
+      
+      def cache_file
+        cache_file = File.join(cache_path,'radiant_config_cache.txt')
+      end
+      
+      def site_settings
+        @site_settings ||= %w{ site.title site.host dev.host local.timezone }
+      end
+      
+      def default_settings
+        @default_settings ||= %w{ defaults.locale defaults.page.filter defaults.page.parts defaults.page.fields defaults.page.status defaults.snippet.filter }
+      end
+      
+      def user_settings
+        @user_settings ||= ['user.allow_password_reset?']
+      end
+      
+      # A convenient drying method for specifying a prefix and options common to several settings.
+      # 
+      #   TrustyCms.config do |config|
+      #     config.namespace('secret', :allow_display => false) do |secret|
+      #       secret.define('identity', :default => 'batman')      # defines 'secret.identity'
+      #       secret.define('lair', :default => 'batcave')         # defines 'secret.lair'
+      #       secret.define('longing', :default => 'vindication')  # defines 'secret.longing'
+      #     end
+      #   end
+      #
+      def namespace(prefix, options = {}, &block)
+        prefix = [options[:prefix], prefix].join('.') if options[:prefix]
+        with_options(options.merge(:prefix => prefix), &block)
+      end
+      
+      # Declares a setting definition that will constrain and support the use of a particular config entry.
+      #
+      #   define('setting.key', options)
+      #
+      # Can take several options:
+      # * :default is the value that will be placed in the database if none has been set already
+      # * :type can be :string, :boolean or :integer. Note that all settings whose key ends in ? are considered boolean.
+      # * :select_from should be a list or hash suitable for passing to options_for_select, or a block that will return such a list at runtime
+      # * :validate_with should be a block that will receive a value and return true or false. Validations are also implied by type or select_from.
+      # * :allow_blank should be false if the config item must not be blank or nil
+      # * :allow_change should be false if the config item can only be set, not changed. Add a default to specify an unchanging config entry.
+      # * :allow_display should be false if the config item should not be showable in radius tags
+      #
+      # From the main radiant config/initializers/radiant_config.rb:
+      #
+      #   TrustyCms.config do |config|
+      #     config.define 'defaults.locale', :select_from => lambda { TrustyCms::AvailableLocales.locales }, :allow_blank => true
+      #     config.define 'defaults.page.parts', :default => "Body,Extended"
+      #     ...
+      #   end
+      #
+      # It's also possible to reuse a definition by passing it to define:
+      #
+      #   choose_layout = TrustyCms::Config::Definition.new(:select_from => lambda {Layout.all.map{|l| [l.name, l.d]}})
+      #   define "my.layout", choose_layout
+      #   define "your.layout", choose_layout
+      #
+      # but at the moment that's only done in testing.
+      #
+      def define(key, options={})
+        called_from = caller.grep(/\/initializers\//).first
+        if options.is_a? TrustyCms::Config::Definition
+          definition = options
+        else
+          key = [options[:prefix], key].join('.') if options[:prefix]
+        end
+
+        raise LoadError, %{
+Config definition error: '#{key}' is defined twice:
+1. #{called_from}
+2. #{definitions[key].definer}
+        } unless definitions[key].nil? || definitions[key].empty?
+
+        definition ||= TrustyCms::Config::Definition.new(options.merge(:definer => called_from))
+        definitions[key] = definition
+
+        if self[key].nil? && !definition.default.nil?
+          begin
+            self[key] = definition.default
+          rescue ActiveRecord::RecordInvalid
+            raise LoadError, "Default configuration invalid: value '#{definition.default}' is not allowed for '#{key}'"
+          end
+        end
+      end
+      
+      def definitions
+        TrustyCms.config_definitions
+      end
+      
+      def definition_for(key)
+        definitions[key] ||= TrustyCms::Config::Definition.new(:empty => true)
+      end
+      
+      def clear_definitions!
+        TrustyCms.config_definitions = {}
+      end
+      
+    end
+    
+    # The usual way to use a config item:
+    #
+    #    TrustyCms.config['key'] = value
+    #
+    # is equivalent to this:
+    #
+    #   TrustyCms::Config.find_or_create_by_key('key').value = value
+    #
+    # Calling value= also applies any validations and restrictions that are found in the associated definition.
+    # so this will raise a ConfigError if you try to change a protected config entry or a RecordInvalid if you 
+    # set a value that is not among those permitted.
+    #
+    def value=(param)
+      newvalue = param.to_s
+      if newvalue != self[:value]
+        raise ConfigError, "#{self.key} cannot be changed" unless settable? || self[:value].blank?
+        if boolean?
+          self[:value] = (newvalue == "1" || newvalue == "true") ? "true" : "false"
+        else
+          self[:value] = newvalue
+        end
+        self.save!
+      end
+      self[:value]
+    end
+
+    # Requesting a config item:
+    #
+    #    key = TrustyCms.config['key']
+    #
+    # is equivalent to this:
+    #
+    #   key = TrustyCms::Config.find_or_create_by_key('key').value
+    #
+    # If the config item is boolean the response will be true or false. For items with :type => :integer it will be an integer, 
+    # for everything else a string.
+    # 
+    def value
+      if boolean?
+        checked?
+      else
+        self[:value]
+      end
+    end
+
+    # Returns the definition associated with this config item. If none has been declared this will be an empty definition
+    # that does not restrict use.
+    #
+    def definition
+      @definition ||= self.class.definition_for(self.key)
+    end
+
+    # Returns true if the item key ends with '?' or the definition specifies :type => :boolean.
+    #
+    def boolean?
+      definition.boolean? || self.key.ends_with?("?")
+    end
+    
+    # Returns true if the item is boolean and true.
+    #
+    def checked?
+      return nil if self[:value].nil?
+      boolean? && self[:value] == "true"
+    end
+    
+    # Returns true if the item defintion includes a :select_from parameter that limits the range of permissible options.
+    #
+    def selector?
+      definition.selector?
+    end
+    
+    # Returns a name corresponding to the current setting value, if the setting definition includes a select_from parameter.
+    #
+    def selected_value
+      definition.selected(value)
+    end
+    
+    def update_cache
+      TrustyCms::Config.initialize_cache
+    end
+
+    delegate :default, :type, :allow_blank?, :hidden?, :visible?, :settable?, :selection, :notes, :units, :to => :definition
+
+    def validate
+      definition.validate(self)
+    end
+
+  end
+end

data/app/models/trusty_cms/page_response_cache_director.rb

@@ -0,0 +1,43 @@
+module TrustyCms
+  class PageResponseCacheDirector
+    def initialize(page, listener)
+      @page = page
+      @listener = listener
+    end
+
+    def set_cache_control
+      cacheable? ? cacheable_response : non_cacheable_response
+    end
+
+    class << self
+      def cache_timeout
+        @cache_timeout ||= 5.minutes
+      end
+
+      def cache_timeout=(val)
+        @cache_timeout = val
+      end
+    end
+
+    private
+
+    def non_cacheable_response
+      @listener.set_expiry nil, :private => true, "no-cache" => true
+      @listener.set_etag('')
+    end
+
+    def cacheable_response
+      timeout = self.class.cache_timeout
+      if @page.respond_to?(:cache_timeout)
+        timeout = @page.cache_timeout
+      end
+
+      @listener.set_expiry timeout, :public => true, :private => false
+    end
+
+    def cacheable?
+      @listener.cacheable_request? && @page.cache?
+    end
+
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,96 @@
+require 'digest/sha1'
+
+class User < ActiveRecord::Base
+  has_many :pages, :foreign_key => :created_by_id
+
+  # Default Order
+  default_scope :order => 'name'
+
+  # Associations
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+
+  # Validations
+  validates_uniqueness_of :login
+
+  validates_confirmation_of :password, :if => :confirm_password?
+
+  validates_presence_of :name, :login
+  validates_presence_of :password, :password_confirmation, :if => :new_record?
+
+  validates_format_of :email, :allow_nil => true, :with => /^$|^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+
+  validates_length_of :name, :maximum => 100, :allow_nil => true
+  validates_length_of :login, :within => 3..40, :allow_nil => true
+  validates_length_of :password, :within => 5..40, :allow_nil => true, :if => :validate_length_of_password?
+  validates_length_of :email, :maximum => 255, :allow_nil => true
+
+  attr_writer :confirm_password
+  class << self
+    def unprotected_attributes
+      @unprotected_attributes ||= [:name, :email, :login, :password, :password_confirmation, :locale]
+    end
+
+    def unprotected_attributes=(array)
+      @unprotected_attributes = array.map{|att| att.to_sym }
+    end
+  end
+
+  def has_role?(role)
+    respond_to?("#{role}?") && send("#{role}?")
+  end
+
+  def sha1(phrase)
+    Digest::SHA1.hexdigest("--#{salt}--#{phrase}--")
+  end
+
+  def self.authenticate(login_or_email, password)
+    user = where(["login = ? OR email = ?", login_or_email, login_or_email]).first
+    user if user && user.authenticated?(password)
+  end
+
+  def authenticated?(password)
+    self.password == sha1(password)
+  end
+
+  def after_initialize
+    @confirm_password = true
+  end
+
+  def confirm_password?
+    @confirm_password
+  end
+
+  def remember_me
+    update_attribute(:session_token, sha1(Time.now + TrustyCms::Config['session_timeout'].to_i)) unless self.session_token?
+  end
+
+  def forget_me
+    update_attribute(:session_token, nil)
+  end
+
+  private
+
+    def validate_length_of_password?
+      new_record? or not password.to_s.empty?
+    end
+
+    before_create :encrypt_password
+    def encrypt_password
+      self.salt = Digest::SHA1.hexdigest("--#{Time.now}--#{login}--sweet harmonious biscuits--")
+      self.password = sha1(password)
+    end
+
+    before_update :encrypt_password_unless_empty_or_unchanged
+    def encrypt_password_unless_empty_or_unchanged
+      user = self.class.find(self.id)
+      case password
+      when ''
+        self.password = user.password
+      when user.password
+      else
+        encrypt_password
+      end
+    end
+
+end

data/app/models/user_action_observer.rb

@@ -0,0 +1,25 @@
+class UserActionObserver < ActiveRecord::Observer
+  observe User, Page, Layout
+  
+  def current_user=(user)
+    self.class.current_user = user
+  end
+  def self.current_user=(user)
+    Thread.current[:current_user] = user
+  end
+  
+  def current_user
+    self.class.current_user
+  end
+  def self.current_user
+    Thread.current[:current_user]
+  end
+  
+  def before_create(model)
+    model.created_by = self.current_user
+  end
+  
+  def before_update(model)
+    model.updated_by = self.current_user
+  end
+end

data/app/views/admin/configuration/edit.html.haml

@@ -0,0 +1,38 @@
+- body_classes << "reversed"
+- @selected = :general
+
+- render_region :main do |main|
+  - main.edit_header do
+    %h1 Configuration
+
+  - main.edit_form do
+    - form_for :trusty_config, :url => admin_configuration_url, :html => {"data-onsubmit_status"=>"Saving changes&#8230;", :method => :put} do |f|
+      = render_region :form_top
+      - render_region :form do |form|
+        - form.edit_site do
+          %fieldset
+            %h3 Site  
+            - TrustyCms.config.site_settings.each do |site_setting|
+              %p
+                = edit_config site_setting
+  
+        - form.edit_defaults do
+          %fieldset
+            %h3 Defaults
+            - TrustyCms.config.default_settings.each do |default_setting|
+              %p
+                = edit_config default_setting
+  
+        - form.edit_users do
+          %fieldset
+            %h3 Passwords
+            - TrustyCms.config.user_settings.each do |user_setting|
+              %p
+                = edit_config user_setting
+    
+      - render_region :form_bottom do |form_bottom|
+        - form_bottom.edit_buttons do
+          .buttons
+            %input.button{:type=>"submit", :value=>"Save Changes"}/
+            or
+            = link_to "Cancel", admin_configuration_url

data/app/views/admin/configuration/show.html.haml

@@ -0,0 +1,58 @@
+- body_classes << "reversed"
+
+#preferences.box
+  - render_region :user do |user|
+    - user.preferences do
+      %h3
+        .actions
+          = button_to t("edit_preferences"), "/admin/preferences", :method => :get
+        = t('personal_preferences')
+      = image_tag(gravatar_url(@user.email, :size=>"64px"), :class=>"avatar", :width=>64, :height=>64, :alt=>"")
+      %p.ruled
+        %label 
+          = t('name') 
+        %span
+          = current_user.name
+      %p.ruled
+        %label 
+          = t('email_address') 
+        %span.uri 
+          = current_user.email
+      %p.ruled
+        %label 
+          = t('login') 
+        %span
+          = current_user.login
+      %p.ruled
+        %label 
+          = t('password') 
+        %big &bull;&bull;&bull;&bull;&bull;
+      %p.ruled
+        %label
+          = t('language') 
+        %span 
+          = current_user.locale
+
+#config.box
+  - render_region :trusty_config do |config|
+    - config.site do
+      %h3
+        - if admin?
+          .actions
+            = button_to t("edit_configuration"), edit_admin_configuration_url, :method => :get
+        Configuration
+      - TrustyCms.config.site_settings.each do |site_setting|
+        %p.ruled
+          = show_config site_setting, :class => (site_setting =~ /host$/ ? 'uri' : nil)
+
+    - config.defaults do
+      %h4 Defaults
+      - TrustyCms.config.default_settings.each do |default_setting|
+        %p.ruled
+          = show_config default_setting
+
+    - config.users do
+      %h4 Passwords
+      - TrustyCms.config.user_settings.each do |user_setting|
+        %p.ruled
+          = show_config user_setting

data/app/views/admin/extensions/index.html.haml

@@ -0,0 +1,41 @@
+- @page_title = t('extensions') + ' - ' + default_page_title
+
+- content_for :page_css do
+  :sass
+    table.index 
+      h4
+        font-size: 110%
+        margin-top: .5em
+        margin-bottom: .25em
+      p
+        margin-top: .25em
+        margin-bottom: .5em
+
+= render_region :top
+
+.outset
+  %table#extensions.index
+    %thead
+      %tr
+        - render_region :thead do |thead|
+          - thead.title_header do
+            %th.extension= t('extension')
+          - thead.website_header do
+            %th.website= t('more_info') 
+          - thead.version_header do
+            %th.version= t('version')
+    %tbody
+      - @extensions.each do |extension|
+        %tr.node.level_1
+          - render_region :tbody, :locals => {:extension => extension} do |tbody|
+            - tbody.title_cell do
+              %td.extension
+                %h4= h extension.extension_name
+                %p= h extension.description
+            - tbody.website_cell do 
+              %td.website
+                = extension.url.nil? || extension.url.empty? ? "" : link_to(t('more_info'), extension.url, :target => "_blank")
+            - tbody.version_cell do
+              %td.version= h extension.version
+
+= render_region :bottom