adva 0.0.1 → 0.1.0

data/app/helpers/activities_helper.rb

@@ -0,0 +1,73 @@
+module ActivitiesHelper
+  def render_activities(activities, recent = false)
+    if activities.present?
+      html = activities.collect do |activity|
+        render :partial => "admin/activities/#{activity.object_type.downcase}",
+               :locals => { :activity => activity, :recent => recent }
+      end.join
+    else
+      html = %(<li class="empty shade">#{I18n.t(:'adva.activity.none')}.</li>)
+    end
+    raw %(<ul class="activities">#{html}</ul>)
+  end
+
+  def activity_css_classes(activity)
+    type = activity.object_attributes['type'] || activity.object_type
+    "#{type}_#{activity.all_actions.last}".downcase
+    # activity.all_actions.collect {|action| "#{type}-#{action}".downcase }.uniq * ' '
+  end
+
+  def activity_datetime(activity, short = false)
+    if activity.from and short
+      from = activity.from.to_s(:time_only)
+      to = activity.to.to_s(:time_only)
+      "#{from} - #{to}"
+    elsif activity.from and activity.from.to_date != activity.to.to_date
+      from = activity.from.to_ordinalized_s(:plain)
+      to = activity.to.to_ordinalized_s(:plain)
+      "#{from} - #{to}"
+    elsif activity.from
+      from = activity.from.to_ordinalized_s(:plain)
+      to = activity.to.to_ordinalized_s(:time_only)
+      "#{from} - #{to}"
+    else
+      activity.created_at.send *(short ? [:to_s, :time_only] :  [:to_ordinalized_s, :plain])
+    end
+  end
+
+  # def activity_datetime(activity, short = false)
+  #   from, to = if activity.from && short
+  #     [l(activity.from, :format => :time), l(activity.to, :format => :time)]
+  #   elsif activity.from && activity.from.to_date != activity.to.to_date
+  #     [l(activity.from, :format => :short), l(activity.to, :format => :short)]
+  #   elsif activity.from
+  #     [l(activity.from, :format => :short), l(activity.to, :format => :time)]
+  #   end
+
+  #   t(:'adva.activity.from_to', :from => from, :to => to)
+  # end
+
+  def activity_object_edit_url(activity)
+    type = activity.object_attributes['type'] || activity.object_type
+    send "edit_admin_#{type}_path".downcase, activity.site_id, activity.section_id, activity.object_id
+  end
+
+  # FIXME not used anywhere?
+  # def activity_commentable_edit_url(activity)
+  #   type = activity.object_attributes['commentable_type']
+  #   send "edit_admin_#{type}_path".downcase, activity.site_id, activity.section_id, activity.commentable_id
+  # end
+  
+  # FIXME not used anywhere?
+  # def link_to_activity_commentable(activity)
+  #   link_to truncate(activity.commentable_title, 100), activity_commentable_url(activity)
+  # end
+
+  def link_to_activity_user(activity)
+    if activity.author.registered?
+      link_to activity.author_name, admin_user_path(activity.author)
+    else
+      activity.author_link(:include_email => true)
+    end
+  end
+end

data/app/helpers/admin/base_helper.rb

@@ -0,0 +1,104 @@
+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, :category], :to => [:admin, :section, :category]
+  define_shallow_resource_helpers :from => [:admin, :content], :to => [:admin, :section, :content]
+  define_shallow_resource_helpers :from => [:admin, :article], :to => [:admin, :section, :article]
+  define_shallow_resource_helpers :from => [:admin, :link], :to => [:admin, :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(options = {})
+    name = options[:name].nil? ? t(:'adva.links.profile') : options[:name]
+    path = admin_user_path(current_user)
+    link_to(name, path)
+  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/content_helper.rb

@@ -0,0 +1,97 @@
+module ContentHelper
+  def published_at_formatted(article)
+    unless article && article.published?
+      if article.published_at&.future?
+        "Will publish on " + l(article.published_at, :format => (article.published_at.year == Time.now.year ? :short : :long))
+      else
+        "Draft"
+      end
+    else
+      l(article.published_at, :format => (article.published_at.year == Time.now.year ? :short : :long))
+    end
+  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, options={}
+    link.body_html
+  end
+
+  def content_path(section, content, options={})
+    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,125 @@
+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
+    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/app/helpers/users_helper.rb

@@ -0,0 +1,28 @@
+module UsersHelper
+  def who(name)
+    name = name.name if name.is_a? User
+    return current_user.name == name ? t(:'adva.common.you') : name
+  end
+
+  def gravatar_img(user, options = {})
+    image_tag gravatar_url(user.email), {:class => 'avatar'}.merge(options)
+  end
+
+  def gravatar_url(email = nil, size = 80)
+    default = '/assets/adva_cms/avatar.gif'
+    return default if Rails.env.test?
+    return default if email.blank?
+    require 'digest/md5'
+    digest = Digest::MD5.hexdigest(email)
+    # TODO #{ActionController::AbstractRequest.relative_url_root} missing in Rails 2.2
+    "http://www.gravatar.com/avatar.php?size=#{size}&gravatar_id=#{digest}&default=http://#{request.host_with_port}/assets/adva_cms/avatar.gif"
+  end
+
+  def link_to_author resource, options = {}
+    include_email = options[:include_email] && resource.respond_to?(:author_email)
+    name = resource.author_name
+    text = resource.author_homepage.blank? ? name : link_to(h(name), h(resource.author_homepage))
+    text = "#{text} (#{resource.author_email})" if include_email
+    text.html_safe
+  end
+end

data/app/models/activity.rb

@@ -0,0 +1,88 @@
+class Activity < ActiveRecord::Base
+  belongs_to :site
+  belongs_to :section
+  belongs_to :object, :polymorphic => true
+
+  prepend Module.new {
+    def method_missing(name, *args)
+      attrs = self[:object_attributes]
+      return attrs[name.to_s] if attrs && attrs.has_key?(name.to_s)
+      super name, *args
+    end
+  }
+
+  belongs_to_author
+
+  serialize :actions
+  serialize :object_attributes
+
+  validates_presence_of :site, :section, :object
+
+  attr_accessor :siblings
+
+  class << self
+    def find_coinciding_grouped_by_dates(*dates)
+      groups = (1..dates.size).collect{[]}
+      activities = find_coinciding #, :include => :user
+
+      # collect activities for the given dates
+      activities.each do |activity|
+        activity_date = activity.created_at.to_date
+        dates.each_with_index {|date, i| groups[i] << activity and break if activity_date == date }
+      end
+
+      # remove all found activities from the original resultset
+      groups.each{|group| group.each{ |activity| activities.delete(activity) }}
+
+      # push remaining resultset as a group itself (i.e. 'the rest of them')
+      groups << activities
+    end
+
+    def find_coinciding(options = {})
+      activities = order(created_at: :desc).limit(50)
+      activities = activities.group_by{|r| "#{r.object_type}#{r.object_id}"}.values
+      activities = group_coinciding(activities)
+      activities.sort{|a, b| b.created_at <=> a.created_at }
+    end
+
+    def group_coinciding(activities, delta = nil)
+      activities.inject [] do |chunks, group|
+        chunks << group.shift
+        group.each do |activity|
+          last = chunks.last.siblings.last || chunks.last
+          if last.coincides_with?(activity, delta)
+            chunks.last.siblings << activity
+          else
+            chunks << activity
+          end
+        end
+        chunks
+      end
+    end
+  end
+
+  after_initialize do
+    @siblings = []
+  end
+
+  def coincides_with?(other, delta = nil)
+    delta ||= 1.hour
+    created_at - other.created_at <= delta.to_i
+  end
+
+  # FIXME should be translated!
+  def all_actions
+    actions = Array(siblings.reverse.map(&:actions).compact.flatten) + self.actions
+    previous = nil
+    actions.reject! { |action| (action == previous).tap { previous = action } }
+    actions
+  end
+
+  def from
+    siblings.last.created_at if siblings.present?
+  end
+
+  def to
+    created_at
+  end
+end

data/app/models/article.rb

@@ -0,0 +1,49 @@
+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, case_sensitive: true
+
+  class_attribute :meta_fields, default: %w(keywords description author copyright geourl)
+
+  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
+
+  def default_meta_description
+    sanitizer = defined?(Rails::Html::FullSanitizer) ? Rails::Html::FullSanitizer.new : HTML::FullSanitizer.new
+    sanitized_excerpt = sanitizer.sanitize(excerpt || "").gsub(/\s+/, " ").strip.truncate(160)
+    sanitized_body = sanitizer.sanitize(body || "").gsub(/\s+/, " ").strip.truncate(160)
+    sanitized_excerpt.present? ? sanitized_excerpt : sanitized_body
+  end
+end

data/app/models/categorization.rb

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

data/app/models/category.rb

@@ -0,0 +1,54 @@
+require "awesome_nested_set"
+require "has_permalink"
+
+class Category < ActiveRecord::Base
+  acts_as_nested_set :scope => :section_id
+
+  include HasPermalink
+  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 :categorizations, :dependent => :delete_all
+  has_many :contents, :through => :categorizations, :source => :categorizable, :source_type => 'Content'
+
+  before_save  :update_path
+  after_create :update_paths
+
+  validates_presence_of :section, :title
+  validates_uniqueness_of :permalink, scope: :section_id, case_sensitive: true
+
+  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
+
+    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