adva 0.0.1 → 0.1.0

data/adva_cms/app/controllers/base_controller.rb

@@ -1,82 +0,0 @@
-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/adva_cms/app/helpers/admin/base_helper.rb

@@ -1,106 +0,0 @@
-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/adva_cms/app/helpers/content_helper.rb

@@ -1,90 +0,0 @@
-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/adva_cms/app/helpers/resource_helper.rb

@@ -1,127 +0,0 @@
-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

data/adva_cms/app/models/article.rb

@@ -1,40 +0,0 @@
-class Article < Content
-  # default_scope :order => "#{self.table_name}.published_at DESC"
-
-  filters_attributes :except => [:excerpt, :excerpt_html, :body, :body_html, :cached_tag_list]
-
-  validates_presence_of :title, :body
-  validates_uniqueness_of :permalink, :scope => :section_id
-
-  class << self
-    def locale
-      "en"
-    end
-  end
-
-  def primary?
-    self == section.articles.primary
-  end
-
-  def previous
-    section.articles.published.where(["#{self.class.table_name}.published_at < ?", published_at]).reorder(published_at: :desc).first
-  end
-  alias_method :previous_article, :previous
-
-  def next
-    section.articles.published.where(["#{self.class.table_name}.published_at > ?", published_at]).reorder(published_at: :asc).first
-  end
-  alias_method :next_article, :next
-
-  def has_excerpt?
-    return false if excerpt == "<p>&#160;</p>" # empty excerpt with fckeditor
-    excerpt.present?
-  end
-
-  def full_permalink
-    raise "cannot create full_permalink for an article that belongs to a non-blog section" unless section.is_a?(Blog)
-    # raise "can not create full_permalink for an unpublished article" unless published?
-    date = [:year, :month, :day].map { |key| [key, (published? ? published_at : created_at).send(key)] }.flatten
-    Hash[:permalink, permalink, *date]
-  end
-end

data/adva_cms/app/models/categorization.rb

@@ -1,4 +0,0 @@
-class Categorization < ActiveRecord::Base
-  belongs_to :categorizable, :polymorphic => true
-  belongs_to :category
-end

data/adva_cms/app/models/category.rb

@@ -1,60 +0,0 @@
-class Category < ActiveRecord::Base
-  acts_as_nested_set :scope => :section_id
-  has_permalink :title, :url_attribute => :permalink, :sync_url => true, :only_when_blank => true, :scope => :section_id
-
-  belongs_to :section, :foreign_key => 'section_id'
-  has_many :contents, :through => :categorizations, :source => :categorizable, :source_type => 'Content'
-  has_many :categorizations, :dependent => :delete_all
-
-  before_save  :update_path
-  after_create :update_paths
-
-  validates_presence_of :section, :title
-  validates_uniqueness_of :permalink, :scope => :section_id
-
-  def owners
-    owner.owners << owner
-  end
-
-  def owner
-    section
-  end
-
-  def all_contents
-    Content.by_category(self)
-  end
-
-  protected
-
-    def update_path
-      if permalink_changed?
-        new_path = build_path
-        unless self.path == new_path
-          self.path = new_path
-          @paths_dirty = true
-        end
-      end
-    end
-
-    # FIXME this is not hooked up. same in Section. don't we need to call this anyway?
-    def update_child_paths
-      if @paths_dirty
-        self.all_children.each do |child|
-          child.path = child.build_path
-          child.save
-        end
-        @paths_dirty = false
-      end
-    end
-
-    def build_path
-      self_and_ancestors.map(&:permalink).join('/')
-    end
-
-    def update_paths
-      if parent_id
-        move_to_child_of(parent)
-        section.categories.update_paths!
-      end
-    end
-end

data/adva_cms/app/models/content.rb

@@ -1,155 +0,0 @@
-require 'html_diff'
-
-class Content < ActiveRecord::Base
-  acts_as_nested_set :scope => :section_id
-
-  # TODO is this needed?
-  class Version < ActiveRecord::Base
-    filters_attributes :none => true
-  end
-
-  has_filter :tagged, :categorized,
-             :text  => { :attributes => [:title, :body, :excerpt] },
-             :state => { :states => [:published, :unpublished] }
-
-  acts_as_taggable
-
-  instantiates_with_sti
-  has_permalink :title, :url_attribute => :permalink, :sync_url => true, :only_when_blank => true, :scope => :section_id
-  filtered_column :body, :excerpt
-
-  belongs_to :site
-  belongs_to :section, :touch => true
-  belongs_to_author :validate => true
-
-  has_many :assets, :through => :asset_assignments
-  has_many :asset_assignments # TODO :dependent => :delete_all?
-  has_many :categories, :through => :categorizations
-  has_many :categorizations, -> { includes(:category) }, as: :categorizable, dependent: :destroy
-
-  after_save do
-    categories.each(&:touch)
-  end
-
-  before_validation :set_site
-
-  scope :published, -> {
-    where(['contents.published_at IS NOT NULL AND contents.published_at <= ?', Time.zone.now])
-  }
-
-  scope :drafts, -> {
-    where(published_at: nil)
-  }
-
-  scope :unpublished, -> {
-    drafts
-  }
-
-  scope :by_category, -> (category) {
-    section_type = category.section.class
-    includes([:categories, :section])
-      .where([
-        "categories.lft >= ? AND categories.rgt <= ? AND sections.type = ?",
-        category.lft, category.rgt, section_type.to_s
-      ]).references(:categories, :section)
-  }
-
-  class << self
-    def primary
-      published.first
-    end
-  end
-
-  def to_param
-    permalink
-  end
-
-  def owners
-    owner.owners << owner
-  end
-
-  def owner
-    section
-  end
-
-  def category_titles
-    categories.collect(&:title)
-  end
-
-  attr_accessor :draft
-  def published_at=(published_at)
-    write_attribute(:published_at, draft.to_i == 1 ? nil : published_at)
-  end
-
-  def author_id=(author_id)
-    # FIXME this is only needed because belongs_to_cacheable can't be non-polymorphic, yet
-    self.author = User.find(author_id) if author_id
-  end
-
-  def published_year
-    Time.local(published_at.year, 1, 1)
-  end
-
-  def published_month
-    Time.local(published_at.year, published_at.month, 1)
-  end
-
-  def draft?
-    published_at.nil?
-  end
-
-  def pending?
-    !published?
-  end
-
-  def published?
-    !published_at.nil? && published_at <= Time.zone.now
-  end
-
-  def published_at?(date)
-    published? && date == [:year, :month, :day].map { |key| published_at.send(key).to_s }
-  end
-
-  def state
-    pending? ? :pending : :published
-  end
-
-  def just_published?
-    published? && published_at_changed?
-  end
-
-  def diff_against_version(version)
-    # return '(orginal version)' if version == versions.earliest.version
-    version = versions[version]
-    HtmlDiff.diff(version.excerpt_html + version.body_html, excerpt_html + body_html)
-  end
-
-  # def to_param(key)
-  #   value = if self.respond_to?(key)
-  #     self.send(key)
-  #   elsif [:year, :month, :day].include?(key)
-  #     published_at.send(key)
-  #   else
-  #     super()
-  #   end
-  #   value ? value.to_s : nil
-  # end
-
-  protected
-
-    def set_site
-      self.site_id = section.site_id if section
-    end
-
-    def update_categories(category_ids)
-      category_ids = Array(category_ids).reject(&:blank?)
-      return if category_ids.empty?
-
-      categories.each do |category|
-        category_ids.delete(category.id.to_s) || categories.delete(category)
-      end
-      if category_ids.present?
-        categories << Category.find(:all, :conditions => ['id in (?)', category_ids])
-      end
-    end
-end