adva 0.0.1 → 0.1.0

data/app/models/content.rb

@@ -0,0 +1,176 @@
+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 :asset_assignments # TODO :dependent => :delete_all?
+  has_many :assets, :through => :asset_assignments
+  has_many :categorizations, -> { includes(:category) }, as: :categorizable, dependent: :destroy
+  has_many :categories, :through => :categorizations
+  has_many :activities, :as => :object
+
+  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 cache_key(*timestamp_names)
+    if new_record?
+      "#{model_name.cache_key}/new"
+    else
+      timestamp_names = [:updated_at, :cells_updated_at] if timestamp_names.none?
+      timestamp = timestamp_names.map { |attr| send(attr) }.compact.map(&:to_time).max
+      timestamp = timestamp.utc.to_s(cache_timestamp_format)
+      "#{model_name.cache_key}/#{id}-#{timestamp}"
+    end
+  end
+
+  def cells_updated_at
+    if defined?(OutputFilter::Cells)
+      OutputFilter::Cells.new(nil).send(:cells, body_html).values.map do |name, state, attrs|
+        attrs = HashWithIndifferentAccess.new(attrs)
+        cell = "#{name.camelize}Cell".constantize.new
+        args = [state]
+        attrs.delete "class" # ignore styling class
+        attrs[:format] = :timestamp
+        args << attrs unless attrs.empty?
+        begin
+          cell.render_state *args
+        rescue ArgumentError
+        end
+      end.select { |response| response.is_a?(Time) }.max
+    end
+  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 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

data/app/models/membership.rb

@@ -0,0 +1,6 @@
+class Membership < ActiveRecord::Base
+  belongs_to :site
+  belongs_to :user
+
+  validates_uniqueness_of :site_id, scope: :user_id, case_sensitive: true
+end

data/app/models/password_mailer.rb

@@ -0,0 +1,49 @@
+require "login/mail_config"
+
+class PasswordMailer < ActionMailer::Base
+  include Login::MailConfig
+
+  class << self
+    def handle_user_password_reset_requested!(event)
+      reset_password_email(
+        :user => event.object, 
+        :from => site(event.source.site).email_from,
+        :reset_link => password_reset_link(event.source, event.token), 
+        :token => event.token
+      ).deliver_now
+    end
+
+    def handle_user_password_updated!(event)
+      updated_password_email(
+        :user => event.object, 
+        :from => site(event.source.site).email_from
+      ).deliver_now
+    end
+
+    private
+
+      def password_reset_link(controller, token)
+        controller.send(:url_for, :action => 'edit', :token => token)
+      end
+  end
+  
+  def reset_password_email(attributes = {})
+    @user = attributes[:user]
+    @reset_link = attributes[:reset_link]
+    @token = attributes[:token]
+    mail({
+      to: attributes[:user].email,
+      from: attributes[:from],
+      subject: I18n.t(:'adva.passwords.notifications.reset_password.subject'),
+    })
+  end
+
+  def updated_password_email(attributes = {})
+    @user = attributes[:user]
+    mail({
+      to: attributes[:user].email,
+      from: attributes[:from],
+      subject: I18n.t(:'adva.passwords.notifications.password_updated.subject'),
+    })
+  end
+end

data/app/models/section.rb

@@ -0,0 +1,129 @@
+require "has_options"
+require "has_permalink"
+require "awesome_nested_set"
+require "rails_ext/active_record/sti_instantiation"
+
+class Section < ActiveRecord::Base
+  include HasOptions
+  include HasPermalink
+
+  default_scope -> { order(:lft) }
+
+  class_attribute :types, default: ["Page"]
+  def self.register_type(type)
+    types.push(type) unless types.include?(type)
+  end
+
+  serialize :permissions
+
+  has_option :contents_per_page, :default => 15
+  has_permalink :title, :url_attribute => :permalink, :sync_url => true,
+    :only_when_blank => true, :scope => [ :site_id, :parent_id ]
+  acts_as_nested_set :scope => :site_id
+  instantiates_with_sti
+
+  belongs_to :site, :touch => true
+  has_many :categories, -> { order(:lft) }, dependent: :destroy do
+    def update_paths!
+      paths = Hash[*roots.map { |r|
+        r.self_and_descendants.map { |n| [n.id, { 'path' => n.send(:build_path) }] } }.flatten]
+      update(paths.keys, paths.values)
+    end
+  end
+
+  has_many :contents, -> { order(:lft) }, foreign_key: :section_id
+
+  before_save  :update_path
+  before_create :set_as_published
+  after_create :update_paths
+
+  validates_presence_of :title # :site wtf ... this breaks install_controller#index
+  validates_uniqueness_of :permalink, scope: :site_id, case_sensitive: true
+  validates_numericality_of :contents_per_page, :only_integer => true, :message => :only_integer
+
+  # validates_each :template, :layout do |record, attr, value|
+  #   record.errors.add attr, 'may not contain dots' if value.index('.') # FIXME i18n
+  #   record.errors.add attr, 'may not start with a slahs' if value.index('.') # FIXME i18n
+  # end
+
+  # TODO validates_inclusion_of :contents_per_page, :in => 1..30, :message => "can only be between 1 and 30."
+
+  def to_param
+    permalink
+  end
+
+  def owners
+    owner.owners << owner
+  end
+
+  def owner
+    site
+  end
+
+  def type
+    read_attribute(:type) || 'Section'
+  end
+
+  def tag_counts
+    Content.tag_counts :conditions => "section_id = #{id}"
+  end
+
+  def root_section?
+    self == site.sections.root
+  end
+
+  def state
+    published? ? :published : :pending
+  end
+
+  def published=(published)
+    if published.to_i == 1
+      self.published_at = Time.current if !published_at
+    elsif published.to_i == 0
+      self.published_at = nil
+    end
+  end
+  
+  def published?(parents = false)
+    return true if self == site.sections.root # the root section is always published
+    return false if parents && has_unpublished_ancestor?
+    return false if published_at.nil? || published_at > Time.current
+    return true
+  end
+  alias published published?
+
+  def nav_children
+    contents.roots.published
+  end
+
+  protected
+  
+    def set_as_published
+      self.published_at = published_at || Time.current
+    end
+  
+    def has_unpublished_ancestor?
+      !ancestors.reject(&:published?).empty?
+    end
+
+    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)
+        site.sections.update_paths!
+      end
+    end
+end

data/app/models/site.rb

@@ -0,0 +1,99 @@
+class Site < ActiveRecord::Base
+  serialize :permissions
+  serialize :spam_options
+
+  has_many :sections, :dependent => :destroy do
+    def paths
+      map(&:path)
+    end
+
+    # FIXME can this be on the nested_set?
+    def update_paths!
+      paths = Hash[*roots.map { |r|
+        r.self_and_descendants.map { |n| [n.id, { 'path' => n.send(:build_path) }] } }.flatten]
+      update paths.keys, paths.values
+    end
+  end
+
+  has_many :memberships, :dependent => :delete_all
+  has_many :users, :through => :memberships, :dependent => :destroy
+  has_many :cached_pages, -> { order(updated_at: :desc) }, dependent: :destroy
+  has_many :activities, :dependent => :destroy
+
+  before_validation :downcase_host, :replace_host_spaces # c'mon, can't this be normalize_host or something?
+  before_validation :populate_title
+
+  validates_presence_of :host, :name, :title
+  validates_uniqueness_of :host, case_sensitive: true
+
+  cattr_accessor :multi_sites_enabled, :cache_sweeper_logging
+
+  class_attribute :meta_fields, default: %w(keywords description author copyright geourl)
+
+  class << self
+    def find_by_host!(host)
+      return Site.first if count == 1 && !multi_sites_enabled
+      where("? = ANY (hosts)", host).first or raise ActiveRecord::RecordNotFound
+    end
+
+    def bust_cache!
+      all.each(&:touch)
+    end
+  end
+
+  def multi_sites_enabled?
+    self.class.multi_sites_enabled
+  end
+
+  def owners
+    []
+  end
+
+  def owner
+    nil
+  end
+
+  def section_ids
+    types = Section.types.map { |type| "'#{type}'" }.join(', ')
+    self.class.connection.select_values("SELECT id FROM contents WHERE type IN (#{types}) AND site_id = #{id}")
+  end
+
+  # def tag_counts
+  #   Content.tag_counts :conditions => "site_id = #{id}"
+  # end
+
+  def perma_host
+    host.sub(':', '.')  # Needed to create valid directories in ms-win
+  end
+
+  def grouped_activities
+    activities.find_coinciding_grouped_by_dates(Time.zone.now.to_date, 1.day.ago.to_date)
+  end
+
+  def plugins
+    @plugins ||= Rails.plugins.values.inject(ActiveSupport::OrderedHash.new) do |plugins, plugin|
+      plugin = plugin.clone
+      plugin.owner = self
+      plugins[plugin.name.to_sym] = plugin
+      plugins
+    end
+  end
+
+  def email_from
+    "#{name} <#{email}>" unless name.blank? || email.blank?
+  end
+
+  private
+
+    def downcase_host
+      self.host = host.to_s.downcase
+    end
+
+    def replace_host_spaces # err ... maybe name this a tad less implementation oriented?
+      self.host = host.to_s.gsub(/^\s+|\s+$/, '').gsub(/\s+/, '-')
+    end
+
+    def populate_title
+      self.title = self.name if self.title.blank?
+    end
+end

data/app/models/user.rb

@@ -0,0 +1,106 @@
+class User < ActiveRecord::Base
+  acts_as_authenticated_user
+
+  # TODO how do we work this in?
+  #  acts_as_authenticated_user :token_with => 'Authentication::SingleToken',
+  #                             :authenticate_with => nil
+
+  scope :verified, -> { where.not(verified_at: nil) }
+
+  belongs_to :account
+  has_many :memberships, :dependent => :delete_all
+  has_many :sites, :through => :memberships
+
+  validates_presence_of     :first_name, :email
+  validates_uniqueness_of   :email, case_sensitive: false # i.e. account attributes are unique per application, not per site
+  validates_length_of       :first_name, :within => 1..40
+  validates_length_of       :last_name, :allow_nil => true, :within => 0..40
+  validates_format_of       :email, :allow_nil => true,
+    :with => /(\A(\s*)\Z)|(\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z)/i
+
+  validates_presence_of     :password,                         :if => :password_required?
+  validates_length_of       :password, :within => 4..40,       :if => :password_required?
+
+  class << self
+    def authenticate(credentials)
+      return false unless user = User.find_by_email(credentials[:email])
+      user.authenticate(credentials[:password]) ? user : false
+    end
+    
+    def anonymous(attributes = {}) # FIXME rename to build_anonymous
+      attributes[:anonymous] = true
+      new attributes
+    end
+  end
+
+  def attributes=(attributes)
+    attributes.symbolize_keys!
+    memberships = attributes.delete :memberships
+    super.tap do
+      update_memberships memberships if memberships
+    end
+  end
+
+  def update_memberships(memberships)
+    memberships.each do |site_id, active|
+      site = Site.find(site_id)
+      if active
+        self.sites << site unless member_of?(site)
+      else
+        self.sites.delete(site) if member_of?(site)
+      end
+    end
+  end
+
+  def member_of?(site)
+    sites.include?(site)
+  end
+
+  def verified?
+    !verified_at.nil?
+  end
+
+  def verify!
+    update verified_at: Time.zone.now if verified_at.nil?
+  end
+
+  # def restore!
+  #   update deleted_at: nil if deleted_at
+  # end
+
+  def registered?
+    !new_record? && !anonymous?
+  end
+
+  def name=(name)
+    self.first_name = name
+  end
+
+  def name
+    last_name ? "#{first_name} #{last_name}" : first_name
+  end
+
+  def to_s
+    name
+  end
+
+  def email_with_name
+    "#{name} <#{email}>"
+  end
+
+  def homepage
+    return nil unless self[:homepage]
+
+    self[:homepage][0..6] == 'http://' ? self[:homepage] : 'http://' + self[:homepage]
+  end
+
+  def first_name_from_email
+    self.first_name.blank? && self.email ? self.email.split('@').first : self.first_name
+  end
+
+  protected
+
+    def password_required?
+      !anonymous? && (password_hash.nil? || password.present?)
+    end
+end

data/app/observers/activities/comment_observer.rb

@@ -0,0 +1,33 @@
+if defined?(Comment)
+  module Activities
+    class CommentObserver < Activities::Logger
+
+      observe :comment
+
+      logs_activity do |log|
+        log.edited :if => [:body_changed?, {:not => :new_record?}]
+        log.approved :if => [:approved_changed?, :approved?]
+        log.unapproved :if => [:approved_changed?, :unapproved?]
+      end
+
+      def collect_activity_attributes(record)
+        attrs = record.send(:clone_attributes)
+        attrs = attrs.slice 'commentable_id', 'body', 'author_name', 'author_email', 'author_url'
+        type = record.commentable.has_attribute?('type') ? record.commentable['type'] : record.commentable_type
+        attrs.update('commentable_type' => type, 'commentable_title' => record.commentable.title)
+      end
+
+      def initialize_activity(record)
+        super.tap do |activity|
+          activity.site = record.commentable.site
+          activity.section = record.commentable.section
+          activity.author = record.author
+        end
+      end
+    end
+  end
+else # stub constant to make zeitwerk eagerload happy
+  module Activities
+    class CommentObserver; end
+  end
+end

data/app/views/admin/activities/_content.html.erb

@@ -0,0 +1,15 @@
+<li class="activity <%= activity_css_classes(activity) %> <%= cycle 'highlight', '', :name => "activities" %>">
+  <p class="meta">
+    <%= link_to_activity_user(activity) %><br />
+  </p>
+  <p class="meta">
+    <%= activity_datetime(activity, recent) %>
+  </p>
+
+  <p>
+    <%= t(:'adva.activity.actions', :type => t(:"adva.activity.types.#{activity.object_attributes['type'].tableize.singularize}"),
+      :actions => activity.all_actions.collect { |a| t(:"adva.activity.action_names.#{a.downcase}") }.to_sentence,
+      :activity => (activity.section ? link_to(activity.section.title, [:admin, activity.section, :contents]) : "Deleted Section")).html_safe %>
+  </p>
+  <%= link_to_if activity.section, activity.title, [:edit, :admin, activity.section, activity.object] %>
+</li>

data/app/views/admin/cached_pages/index.html.erb

@@ -0,0 +1,26 @@
+<%= render :partial => 'filter' %>
+
+<%
+	table_for @cached_pages do |t|
+	  t.column :url, :cached_at, :actions
+
+		# t.head.row do |r|
+		# 	r.cell t(:'adva.cached_pages.total_with_count', :count => @cached_pages.total_entries), :class => :total, :colspan => :all
+		# end
+
+		t.row do |r, cached_page|
+		  r.cell cached_page.url
+  		r.cell page_cached_at(cached_page)
+			r.cell link_to(t(:'adva.titles.clear'), admin_cached_page_path(cached_page), :class => 'text clear')
+
+		end
+
+		t.foot.row do |r|
+			r.cell will_paginate(@cached_pages), :class => :pagination, :colspan => :all
+		end
+
+		t.empty :p, :class => 'empty' do
+			t(params[:query].present? ? :'adva.cached_pages.no_entries_matching_criteria' : :'adva.cached_pages.no_entries')
+		end
+	end
+%>

data/app/views/admin/install/confirmation.html.erb

@@ -0,0 +1,10 @@
+<h2><%= t(:'adva.titles.success') %></h2>
+
+<p>
+  <%= t(:'adva.sites.install.success_fully_created') %>
+</p>
+
+<p>
+  <%= link_to t(:'adva.sites.links.manage_new'), admin_site_path %>
+</p>
+