adva_cms 0.0.1

data/app/controllers/base_controller.rb

@@ -0,0 +1,82 @@
+class BaseController < ApplicationController
+  class SectionRoutingError < ActionController::RoutingError; end
+  helper :base, :resource, :content
+  helper HasFilter::Helper
+  helper TableBuilder
+
+  include CacheableFlash
+  include ContentHelper
+  include ResourceHelper
+
+  before_filter :set_site, :set_timezone
+  attr_accessor :site, :section
+
+  layout 'default'
+
+  protected
+    def set_site
+      @site ||= Site.find_by_host!(request.host_with_port)
+    end
+    alias :site :set_site
+
+    def sections
+      @sections ||= site.sections
+    end
+    helper_method :sections
+
+    def set_section
+      @section ||= begin
+        sections.find_by_permalink(params[:section_permalink]) || sections.first
+      end
+      raise ActiveRecord::RecordNotFound unless @section.published?(true) || has_permission?('update', 'section')
+      @section
+    end
+    alias :section :set_section
+
+    def set_timezone
+      Time.zone = @site.timezone if @site
+    end
+
+    def current_page
+      @page ||= begin
+        page = params[:page].to_i
+        page = 1 if page == 0
+        page
+      end
+    end
+
+    def set_commentable
+      @commentable = @article || @section || @site
+    end
+
+    def rescue_action(exception)
+      if exception.is_a?(ActionController::RoleRequired)
+        redirect_to_login(exception.message)
+      else
+        super
+      end
+    end
+
+    def redirect_to_login(notice = nil)
+      redirect_to login_url(return_to: request.url), notice: notice
+    end
+
+    def return_from(action, options = {})
+      URI.unescape(params[:return_to] || options[:default] || '/')
+    end
+    
+    def current_resource
+      @section || @site
+    end
+
+    def skip_caching?
+      @skip_caching or @article.try(:draft?)
+    end
+
+    def skip_caching!
+      @skip_caching = true
+    end
+end
+
+
+

data/app/helpers/admin/base_helper.rb

@@ -0,0 +1,106 @@
+module Admin::BaseHelper
+  def self.define_shallow_resource_helpers options
+    from = options.delete(:from)
+    to = options.delete(:to)
+
+    from_namespace = from[0..-2].collect(&:to_s).join("_")
+    to_namespace = to[0..-2].collect(&:to_s).join("_")
+    resource = from[-1].to_s
+
+    def self.define_path_and_url_methods options
+      from = options.delete(:from)
+      to = options.delete(:to)
+
+      %w(path url).each do |suffix|
+        eval "def #{from}_#{suffix} *args; #{to}_#{suffix} *args; end"
+      end
+    end
+
+    # index
+    define_path_and_url_methods \
+      :from => [from_namespace, resource.pluralize].join("_"),
+      :to => [to_namespace, resource.pluralize].join("_")
+
+    # show
+    define_path_and_url_methods \
+      :from => [from_namespace, resource].join("_"),
+      :to => [to_namespace, resource].join("_")
+
+    # new
+    define_path_and_url_methods \
+      :from => [:new, from_namespace, resource].join("_"),
+      :to => [:new, to_namespace, resource].join("_")
+
+    # edit
+    define_path_and_url_methods \
+      :from => [:edit, from_namespace, resource].join("_"),
+      :to => [:edit, to_namespace, resource].join("_")
+  end
+
+  define_shallow_resource_helpers :from => [:admin, :section], :to => [:admin, :site, :section]
+
+  define_shallow_resource_helpers :from => [:admin, :category], :to => [:admin, :site, :section, :category]
+  define_shallow_resource_helpers :from => [:admin, :content], :to => [:admin, :site, :section, :content]
+  define_shallow_resource_helpers :from => [:admin, :article], :to => [:admin, :site, :section, :article]
+  define_shallow_resource_helpers :from => [:admin, :link], :to => [:admin, :site, :section, :link]
+
+
+  def save_or_cancel_links(builder, options = {})
+    save_text   = options.delete(:save_text)   || t(:'adva.common.save')
+    or_text     = options.delete(:or_text)     || t(:'adva.common.connector.or')
+    cancel_text = options.delete(:cancel_text) || t(:'adva.common.cancel')
+    cancel_url  = options.delete(:cancel_url)
+
+    save_options = options.delete(:save) || {}
+    save_options.reverse_merge!(:id => 'commit')
+    cancel_options = options.delete(:cancel) || {}
+
+    builder.buttons do
+      ''.html_safe.tap do |buttons|
+        buttons << submit_tag(save_text, save_options)
+        buttons << " #{or_text} #{link_to(cancel_text, cancel_url, cancel_options)}".html_safe if cancel_url
+      end
+    end.html_safe
+  end
+
+  def link_to_profile(site = nil, options = {})
+    name = options[:name].nil? ? t(:'adva.links.profile') : options[:name]
+    site = nil if site.try(:new_record?)
+    link_to(name, admin_user_path(site, current_user))
+  end
+
+  def links_to_content_translations(content, &block)
+    return '' if content.new_record?
+    block = Proc.new { |locale| link_to_edit(locale, content, :cl => locale) } unless block
+    locales = content.translated_locales.map { |locale| block.call(locale.to_s) }
+    content_tag(:span, :class => 'content_translations') do
+      t(:"adva.#{content[:type].tableize}.translation_links", :locales => locales.join(', ')) +
+      "<p class=\"hint\" for=\"content_translations\">#{t(:'adva.hints.content_translations')}</p>"
+    end
+  end
+
+  def link_to_clear_cached_pages(site)
+    link_to(t(:'adva.cached_pages.links.clear_all'), admin_cached_pages_path(site), :method => :delete)
+  end
+
+  def link_to_restore_plugin_defaults(site, plugin)
+    link_to(t(:'adva.titles.restore_defaults'), admin_plugin_path(site, plugin), :data => { :confirm => t(:'adva.plugins.confirm_reset') })
+  end
+
+  # FIXME: translations
+  def page_cached_at(page)
+    if Date.today == page.updated_at.to_date
+      if page.updated_at > Time.zone.now - 4.hours
+        "#{time_ago_in_words(page.updated_at).gsub(/about /,'~ ')} ago"
+      else
+        "Today, #{page.updated_at.strftime('%l:%M %p')}"
+      end
+    else
+      page.updated_at.strftime("%b %d, %Y")
+    end
+  end
+
+  def editor_class_for content
+    "big wysiwyg"
+  end
+end

data/app/helpers/base_helper.rb

@@ -0,0 +1,56 @@
+module BaseHelper
+  def column(&block)
+    content_tag(:div, :class => 'col', &block)
+  end
+
+  def buttons(&block)
+    content_tag(:p, :class => 'buttons', &block)
+  end
+
+  # does exactly the same as the form_for helper does, but splits off the
+  # form head tag and captures it to the content_for :form collector
+  def split_form_for(*args, &block)
+    # for some weird reasons Passenger and Mongrel behave differently when using Rails' capture method
+    # with_output_buffer -> works, so we use it for now
+    lines = (form_for(*args, &block) || '').split("\n")
+    content_for :form, lines.shift.html_safe
+    lines.pop
+
+    lines.join("\n").html_safe
+  end
+
+  def datetime_with_microformat(datetime, options={})
+    return datetime unless datetime.respond_to?(:strftime)
+    options.symbolize_keys!
+    options[:format] ||= :default
+    options[:type]   ||= :time
+    # yuck ... use the localized_dates plugin as soon as we're on Rails 2.2?
+    # formatted_datetime = options[:format].is_a?(Symbol) ? datetime.clone.in_time_zone.to_s(options[:format]) : datetime.clone.in_time_zone.strftime(options[:format])
+    formatted_datetime = l(datetime.in_time_zone.send(options[:type].to_sym == :time ? :to_time : :to_date), :format => options[:format])
+
+    %{<abbr class="datetime" title="#{datetime.utc.xmlschema}">#{formatted_datetime}</abbr>}.html_safe
+  end
+
+  def filter_options
+    FilteredColumn.filters.keys.inject([]) do |arr, key|
+      arr << [FilteredColumn.filters[key].filter_name, key.to_s]
+    end.unshift [t(:'adva.settings.filter_options.plain_html'), '']
+  end
+
+  def author_options(users)
+    authors = [[current_user.name, current_user.id]]
+    authors += users.map { |author| [author.name, author.id] }
+    authors.uniq
+  end
+
+  def author_selected(content = nil)
+    # FIXME why would we want to preselect the previous author of the
+    #       content when we are editing it?
+    # content.try(:author_id) || current_user.id
+    current_user.id
+  end
+  
+  def link_path(section, link, *args)
+    link.body_html
+  end
+end

data/app/helpers/content_helper.rb

@@ -0,0 +1,90 @@
+module ContentHelper
+  def published_at_formatted(article)
+    return t(:'adva.contents.not_published') unless article && article.published?
+    l(article.published_at, :format => (article.published_at.year == Time.now.year ? :short : :long))
+  end
+
+  # def article_url(section, article, options = {})
+  #   if article.section.is_a?(Blog)
+  #     blog_article_url(section, article.full_permalink.merge(options))
+  #   else
+  #     page_article_url(*[section, article.permalink, options].compact)
+  #   end
+  # end
+
+  def page_link_path section, link
+    link.body_html
+  end
+
+  def content_path(section, content)
+    return article_path(section, content) if content.is_a? Article
+    link_path(section, content)
+  end
+
+  def content_status(content)
+    return "<span>&nbsp;</span>" unless content.respond_to?(:published?)
+    klass = content.published? ? 'published' : 'pending'
+    text  = content.published? ? t(:'adva.titles.published') : t(:'adva.titles.pending')
+
+    "<span title='#{text}' alt='#{text}' class='status #{klass}'>#{text}</span>"
+  end
+
+  def link_to_preview(*args)
+    options = args.extract_options!
+    content, text = *args.reverse
+
+    text ||= :"adva.#{content.class.name.tableize}.links.preview"
+    url = show_path(content, :cl => content.class.locale, :namespace => nil)
+
+    options.reverse_merge!(:url => url, :class => "preview #{content.class.name.underscore}")
+    link_to_show(text, content, options)
+  end
+
+  def link_to_content(*args)
+    options = args.extract_options!
+    object, text = *args.reverse
+    link_to_show(text || (object.is_a?(Site) ? object.name : object.title), object, options) if object
+  end
+
+  def link_to_category(*args)
+    text = args.shift if args.first.is_a?(String)
+    category = args.pop
+    section = args.pop || category.section
+    route_name = :"#{section.class.name.downcase}_category_path"
+    text ||= category.title
+    link_to(text, send(route_name, :section_id => section.id, :category_id => category.id))
+  end
+
+  def links_to_content_categories(content, key = nil)
+    return if content.categories.empty?
+    links = content.categories.map { |category| link_to_category content.section, category }
+    key ? t(key, :links => links.join(', ')) : links
+  end
+
+  def link_to_tag(*args, &block)
+    tag = args.pop
+    section = args.pop
+    route_name = :"#{section.class.name.downcase}_tag_path"
+
+    if block_given?
+      link_to(send(route_name, section_permalink: section.permalink, tags: tag), &block)
+    else
+      text = args.pop || tag.name
+      link_to(text, send(route_name, section_permalink: section.permalink, tags: tag))
+    end
+  end
+
+  def links_to_content_tags(content, key = nil)
+    return if content.tags.empty?
+    links = content.tags.map { |tag| link_to_tag content.section, tag }
+    key ? t(key, links: links.join(', ')).html_safe : links
+  end
+
+  def content_category_checkbox(content, category)
+    type = content.type.downcase
+    checked = content.categories.include?(category)
+    name = "#{type}[category_ids][]"
+    id = "#{type}_category_#{category.id}"
+    check_box_tag(name, category.id, checked, :id => id)
+  end
+end

data/app/helpers/resource_helper.rb

@@ -0,0 +1,127 @@
+module ResourceHelper
+  def resource_url(action, resource, options = {})
+    type, resource = *resource.reverse if resource.is_a?(Array)
+    raise "can not generate a url for a new #{resource.class.name}" if resource.try(:new_record?)
+
+    namespace = resource_url_namespace(options)
+    type = normalize_resource_type(action, type, resource)
+    options.reverse_merge!(:only_path => true)
+
+    args = resource_owners(resource) << options
+    args.shift unless namespace.try(:to_sym) == :admin
+
+    send(resource_url_method(namespace, action, type, options), *args.uniq)
+  end
+
+  def resource_link(action, *args)
+    action = action.to_sym
+    url_options = args.extract_options!.dup
+    options = url_options.slice!(:only_path, :namespace, :anchor, :cl) # FIXME rather slice out known link_to options here
+
+    resource, text = *args.reverse
+    type, resource = *resource.reverse if resource.is_a?(Array)
+
+    type = normalize_resource_type(action, type, resource)
+    text = normalize_resource_link_text(text, action, type)
+    options = normalize_resource_link_options(options, action, type, resource)
+
+    resource = [resource, type] if [:index, :new].include?(action)
+    url = options.delete(:url) || resource_url(action, resource, url_options)
+
+    link_to(text, url, options)
+  end
+
+  [:index, :new, :show, :edit, :delete].each do |action|
+    define_method(:"#{action}_url") do |*args|
+      args << options = args.extract_options!
+      options[:only_path] = false
+      resource_url(action, *args)
+    end
+
+    define_method(:"#{action}_path") do |*args|
+      args << options = args.extract_options!
+      options[:only_path] = true
+      resource_url(action, *args)
+    end
+
+    define_method(:"link_to_#{action}") do |*args|
+      resource_link(action, *args)
+    end
+  end
+
+  def links_to_actions(actions, *args)
+    actions.map { |action| resource_link(action, *args) }.join("\n")
+  end
+
+  def normalize_resource_type(action, type, resource)
+    type ||= resource.is_a?(Symbol) ? resource : resource.class.name
+    type = 'section' if type.to_s.classify.constantize < Section
+    type = type.to_s.tableize.gsub("/","_") if action == :index
+    type = type.to_s.split("::").first == "Adva" ? type.to_s.underscore.gsub("/","_") : type.to_s.demodulize.underscore
+    type
+  end
+
+  def resource_url_namespace(options)
+    options.key?(:namespace) ? options.delete(:namespace) : current_controller_namespace
+  end
+
+  def current_controller_namespace
+    path = respond_to?(:controller_path) ? controller_path : controller.controller_path
+    namespace = path.split('/')[0..-2].join('_')
+    namespace.present? ? namespace : nil
+  end
+
+  def resource_link_id(action, type, resource)
+    id = [action, type]
+    id << resource.id if resource.is_a?(ActiveRecord::Base) && !action.in?(:index, :new)
+    id.join('_')
+  end
+
+  def resource_owners(resource)
+    return [] if resource.nil? || resource.is_a?(Symbol)
+    return resource.owners << resource if resource.respond_to?(:owners)
+
+    owners = []
+    if resource.respond_to?(:section)
+      owners << resource.section.site << resource.section
+    elsif resource.respond_to?(:site)
+      owners << resource.site
+    elsif resource.respond_to?(:owner)
+      owners << resource.owner
+    end
+
+    owners << resource
+  end
+
+  def resource_url_method(namespace, action, type, options)
+    method = [namespace, type].compact
+
+    method << (options.delete(:only_path) ? 'path' : 'url')
+    method.unshift(action) if [:new, :edit].include?(action.to_sym)
+
+    method.compact.join('_').gsub('/', '_')
+  end
+
+  def normalize_resource_link_options(options, action, type, resource)
+    options[:class] ||= "#{action} #{type}"
+    options[:id] ||= resource_link_id(action, type, resource)
+    options[:title] ||= t(:"adva.titles.#{action}")
+    options.reverse_merge!(resource_delete_options(type, options)) if action == :delete
+    options
+  end
+
+  def normalize_resource_link_text(text, action, type)
+    type = type.to_s.gsub('/', '_').pluralize
+    text ||= t(:"adva.#{type}.links.#{action}", :default => :"adva.resources.links.#{action}")
+    text = t(text) if text.is_a?(Symbol)
+    text
+  end
+
+  def resource_delete_options(type, options)
+    type = type.to_s.gsub('/', '_').pluralize
+    message = options.delete(:confirm)
+    message ||= t(:"adva.#{type}.confirm_delete", :default => :"adva.resources.confirm_delete")
+    message = t(message) if message.is_a?(Symbol)
+    { :data => { :confirm => message }, :method => :delete }
+  end
+end