proclaim 0.1.0

data/app/controllers/proclaim/subscriptions_controller.rb

@@ -0,0 +1,67 @@
+require_dependency "proclaim/application_controller"
+
+module Proclaim
+	class SubscriptionsController < ApplicationController
+		after_action :verify_authorized, except: [:subscribed, :unsubscribed]
+		before_action :set_subscription, only: [:unsubscribe, :destroy]
+
+		def new
+			@subscription = Subscription.new
+			authorize @subscription
+		end
+
+		def subscribed
+		end
+
+		def unsubscribe
+			authorize @subscription
+		end
+
+		def unsubscribed
+		end
+
+		def create
+			@subscription = Subscription.new(subscription_params)
+
+			authorize @subscription
+
+			if antispam_params[:answer] == antispam_params[:solution]
+				respond_to do |format|
+					if @subscription.save
+						format.html { redirect_to subscribed_path }
+					else
+						format.html { render :new }
+					end
+				end
+			else
+				@subscription.errors.add(:base, "Antispam question wasn't answered correctly")
+				respond_to do |format|
+					format.html { render :new }
+				end
+			end
+		end
+
+		def destroy
+			authorize @subscription
+
+			@subscription.destroy
+			redirect_to unsubscribed_path, notice: "Successfully unsubscribed."
+		end
+
+		private
+
+		def set_subscription
+			@subscription = Subscription.from_token(params[:token])
+		end
+
+		# Only allow a trusted parameter "white list" through.
+		def subscription_params
+			params.require(:subscription).permit(:email)
+		end
+
+		def antispam_params
+			params.require(:antispam).permit(:solution,
+			                                 :answer)
+		end
+	end
+end

data/app/helpers/proclaim/application_helper.rb

@@ -0,0 +1,34 @@
+module Proclaim
+	module ApplicationHelper
+		def comments_tree_for(comments)
+			comments.map do |comment, nested_comments|
+				commentHtml = render(partial: "proclaim/comments/comment",
+				                     formats: [:html],
+				                     locals: {
+				                     	comment: comment,
+				                     	target: "#comment_#{comment.id}_replies"
+				                     })
+
+				nestedComments = ""
+				if nested_comments.size > 0
+					nestedComments = comments_tree_for(nested_comments)
+				end
+
+				repliesHtml = content_tag(:div, nestedComments,
+				                          id: "comment_#{comment.id}_replies",
+				                          class: "replies")
+
+				content_tag(:div, commentHtml + repliesHtml, class: "discussion")
+			end.join.html_safe
+		end
+
+#		def timeago(time, options = {})
+#			options[:class] ||= "timeago"
+#			if time
+#				content_tag(:time,
+#					         time.to_s,
+#					         options.merge(datetime: time.getutc.iso8601))
+#			end
+#		end
+	end
+end

data/app/helpers/proclaim/comments_helper.rb

@@ -0,0 +1,4 @@
+module Proclaim
+	module CommentsHelper
+	end
+end

data/app/helpers/proclaim/images_helper.rb

@@ -0,0 +1,4 @@
+module Proclaim
+  module ImagesHelper
+  end
+end

data/app/helpers/proclaim/posts_helper.rb

@@ -0,0 +1,4 @@
+module Proclaim
+	module PostsHelper
+	end
+end

data/app/helpers/proclaim/subscriptions_helper.rb

@@ -0,0 +1,4 @@
+module Proclaim
+  module SubscriptionsHelper
+  end
+end

data/app/mailers/proclaim/subscription_mailer.rb

@@ -0,0 +1,43 @@
+module Proclaim
+	class SubscriptionMailer < ActionMailer::Base
+		default from: "from@example.com"
+
+		def welcome_email(subscription)
+			@subscription = subscription
+
+			message = Premailer.new(render_to_string, with_html_string: true, base_url: root_url)
+			base_url = root_url.gsub(/\A.*:\/\//, '').gsub(/\A(.*?)\/*\z/, '\1')
+
+			mail to: @subscription.email, subject: "Welcome to #{base_url}!" do |format|
+				format.html { message.to_inline_css }
+				format.text { message.to_plain_text }
+			end
+		end
+
+		def new_comment_notification_email(subscription, comment)
+			@subscription = subscription
+			@comment = comment
+
+			message = Premailer.new(render_to_string, with_html_string: true, base_url: root_url)
+
+			mail to: @subscription.email,
+			     subject: "New Comment On \"#{@comment.post.title}\"" do |format|
+				format.html { message.to_inline_css }
+				format.text { message.to_plain_text }
+			end
+		end
+
+		def new_post_notification_email(subscription, post)
+			@subscription = subscription
+			@post = post
+
+			message = Premailer.new(render_to_string, with_html_string: true, base_url: root_url)
+
+			mail to: @subscription.email,
+			     subject: "New Post: #{@post.title}" do |format|
+				format.html { message.to_inline_css }
+				format.text { message.to_plain_text }
+			end
+		end
+	end
+end

data/app/models/proclaim/comment.rb

@@ -0,0 +1,35 @@
+# == Schema Information
+#
+# Table name: proclaim_comments
+#
+#  id         :integer          not null, primary key
+#  post_id    :integer
+#  parent_id  :integer
+#  author     :string
+#  body       :text
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+module Proclaim
+	class Comment < ActiveRecord::Base
+		acts_as_tree order: 'created_at ASC', dependent: :destroy
+		belongs_to :post, inverse_of: :comments
+		after_initialize :maintainPost
+		after_create :notifyPostSubscribers
+
+		validates_presence_of :body, :author, :post
+
+		private
+
+		def maintainPost
+			if parent
+				self.post = parent.post
+			end
+		end
+
+		def notifyPostSubscribers
+			post.notifyPostSubscribers(self)
+		end
+	end
+end

data/app/models/proclaim/image.rb

@@ -0,0 +1,19 @@
+# == Schema Information
+#
+# Table name: proclaim_images
+#
+#  id         :integer          not null, primary key
+#  post_id    :integer
+#  image      :string
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+module Proclaim
+	class Image < ActiveRecord::Base
+		belongs_to :post, inverse_of: :images
+		mount_uploader :image, ImageUploader
+
+		validates_presence_of :post, :image
+	end
+end

data/app/models/proclaim/post.rb

@@ -0,0 +1,133 @@
+# == Schema Information
+#
+# Table name: proclaim_posts
+#
+#  id               :integer          not null, primary key
+#  author_id        :integer
+#  title            :string           default(""), not null
+#  body             :text             default(""), not null
+#  published        :boolean          default("f"), not null
+#  publication_date :datetime
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#
+
+module Proclaim
+	class Post < ActiveRecord::Base
+		belongs_to :author, class_name: Proclaim.author_class
+		has_many :comments, inverse_of: :post, dependent: :destroy
+		has_many :subscriptions, inverse_of: :post, dependent: :destroy
+		has_many :images, inverse_of: :post, dependent: :destroy
+		accepts_nested_attributes_for :images, allow_destroy: true
+
+		include AASM
+
+		aasm column: :state, no_direct_assignment: true do
+			state :draft, initial: true
+			state :published
+
+			event :publish do
+				transitions from: :draft, to: :published
+
+				before do
+					self.published_at = DateTime.now
+				end
+			end
+		end
+
+		validates_presence_of :published_at, if: :published?
+		validates :published_at, absence: true, unless: :published?
+
+		validates_presence_of :title, :body, :author
+		validate :verifyBodyHtml
+
+		after_save :notifyBlogSubscribersIfPublished
+
+		attr_writer :excerpt_length
+		def excerpt_length
+			@excerpt_length || Proclaim.excerpt_length
+		end
+
+		def body_plaintext
+			Rails::Html::FullSanitizer.new.sanitize(body.gsub(/\r\n?/, ' '))
+		end
+
+		def excerpt
+			document = Nokogiri::HTML.fragment(body)
+
+			unless document.text.empty?
+				takeExcerptOf first_block_element_text(document)
+			else
+				""
+			end
+		end
+
+		def notifyPostSubscribers(newComment)
+			subscriptions.each do | subscription |
+				subscription.deliver_new_comment_notification_email(newComment)
+			end
+		end
+
+		private
+
+		def verifyBodyHtml
+			if not errors.messages.include?(:body) and
+			   body_plaintext.strip.empty? and
+			   Nokogiri::HTML.fragment(body).css("img").empty?
+				errors.add :body, :empty
+			end
+		end
+
+		def takeExcerptOf(text)
+			if excerpt_length >= text.length
+				return text
+			end
+
+			excerpt = text.slice(0, excerpt_length)
+
+			if text.slice(excerpt_length) =~ /\s/
+				return excerpt.strip
+			end
+
+			# Make sure words aren't interrupted
+			excerpt.slice(0, excerpt.rindex(/\s/, excerpt.length)).strip
+		end
+
+		def first_block_element_text(nokogiri_node)
+			if nokogiri_node.text?
+				return block_element_text(nokogiri_node.parent)
+			end
+
+			nokogiri_node.children.each do |child|
+				result = first_block_element_text(child)
+				if result
+					return result
+				end
+			end
+
+			nil
+		end
+
+		def block_element_text(nokogiri_block_element)
+			text = String.new
+			nokogiri_block_element.children.each do | child |
+				if child.text? or (child.description.try(:inline?))
+					text += child.text
+				else
+					break # Stop at the first non-inline non-text element
+				end
+			end
+
+			return text
+		end
+
+		def notifyBlogSubscribersIfPublished
+			# If we just published this post, notify the subscribers
+			if published? and state_changed?
+				Subscription.blog_subscriptions.each do | subscription |
+					subscription.deliver_new_post_notification_email(self)
+				end
+			end
+		end
+	end
+end

data/app/models/proclaim/subscription.rb

@@ -0,0 +1,63 @@
+# == Schema Information
+#
+# Table name: proclaim_subscriptions
+#
+#  id         :integer          not null, primary key
+#  post_id    :integer
+#  email      :string
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+module Proclaim
+	class Subscription < ActiveRecord::Base
+		scope :blog_subscriptions, -> { where(post_id: nil) }
+		belongs_to :post, inverse_of: :subscriptions
+
+		after_create :deliver_welcome_email
+
+		validates :email, uniqueness: { scope: :post_id, case_sensitive: false }, format: { with: /@/ }
+
+		# RFC-compliant email addresses are way nasty to match with regex, so why
+		# try? We'll be sending them an email anyway-- if they don't get it, they
+		# can re-subscribe. We'll just do an easy validation match here.
+		#validates_format_of :email, :with => /@/
+
+		# Subscriptions aren't required to belong to a post, but if we're given
+		# one it had better be valid
+		validates_presence_of :post, if: :post_id
+
+		def deliver_welcome_email
+			SubscriptionMailer.welcome_email(self).deliver_later
+		end
+
+		def deliver_new_post_notification_email(post)
+			SubscriptionMailer.new_post_notification_email(self, post).deliver_later
+		end
+
+		def deliver_new_comment_notification_email(comment)
+			SubscriptionMailer.new_comment_notification_email(self, comment).deliver_later
+		end
+
+		def token
+			Subscription.create_token(self)
+		end
+
+		def self.verifier
+			ActiveSupport::MessageVerifier.new(Rails.application.secrets.secret_key_base)
+		end
+
+		def self.from_token(token)
+			begin
+				id = verifier.verify(token)
+				Subscription.find_by_id(id)
+			rescue ActiveSupport::MessageVerifier::InvalidSignature
+				nil
+			end
+		end
+
+		def self.create_token(subscription)
+			verifier.generate(subscription.id)
+		end
+	end
+end

data/app/policies/application_policy.rb

@@ -0,0 +1,53 @@
+class ApplicationPolicy
+	attr_reader :user, :record
+
+	def initialize(user, record)
+		@user = user
+		@record = record
+	end
+
+	def index?
+		false
+	end
+
+	def show?
+		false
+	end
+
+	def create?
+		false
+	end
+
+	def new?
+		create?
+	end
+
+	def update?
+		false
+	end
+
+	def edit?
+		update?
+	end
+
+	def destroy?
+		false
+	end
+
+	def scope
+		Pundit.policy_scope!(user, record.class)
+	end
+
+	class Scope
+		attr_reader :user, :scope
+
+		def initialize(user, scope)
+			@user = user
+			@scope = scope
+		end
+
+		def resolve
+			scope
+		end
+	end
+end